void Start()
{
castToPlane = new Plane(-Vector3.forward, Vector3.zero);
meshRenderer = shadowPlane.GetComponent<MeshRenderer>();
meshFilter = meshRenderer.GetComponent<MeshFilter>();
mesh = meshFilter.mesh;
meshFilter.mesh = mesh;
vertices = mesh.vertices;
}
void Awake()
{
// Find Cursor Object
Cursor = transform.Find("Cursor").gameObject;
CursorMeshRenderer = Cursor.transform.GetComponentInChildren<MeshRenderer>();
CursorMeshRenderer.GetComponent<Renderer>().material.color = new Color(0.0f, 0.8f, 1.0f);
// Record initial coordinate for reset function
if (Cursor) {
ScreenCoordinate = Cursor.transform.localPosition;
InitCoordiante = Cursor.transform.localPosition;
}
}
public FFacetRenderLayer(FStage stage, FFacetType facetType, FAtlas atlas, FShader shader)
{
this.stage = stage;
this.facetType = facetType;
this.atlas = atlas;
this.shader = shader;
_expansionAmount = facetType.expansionAmount;
_maxEmptyFacets = facetType.maxEmptyAmount;
this.batchIndex = facetType.index*10000000 + atlas.index*10000;
_gameObject = new GameObject("FRenderLayer ("+stage.name+") ("+facetType.name+")");
_transform = _gameObject.transform;
_transform.parent = Futile.instance.gameObject.transform;
_meshFilter = _gameObject.AddComponent<MeshFilter>();
_meshRenderer = _gameObject.AddComponent<MeshRenderer>();
_meshRenderer.castShadows = false;
_meshRenderer.receiveShadows = false;
_mesh = _meshFilter.mesh;
//we could possibly create a pool of materials so they can be reused,
//but that would create issues when unloading textures, so it's probably not worth it
_material = new Material(shader.shader);
_material.mainTexture = atlas.texture;
_meshRenderer.GetComponent<Renderer>().sharedMaterial = _material;
#if UNITY_3_0 || UNITY_3_1 || UNITY_3_2 || UNITY_3_3 || UNITY_3_4 || UNITY_3_5
_gameObject.active = false;
#else
_gameObject.SetActive(false);
_mesh.MarkDynamic();
#endif
ExpandMaxFacetLimit(facetType.initialAmount);
UpdateTransform();
}
public FFacetRenderLayer(FStage stage, FFacetType facetType, FAtlas atlas, FShader shader)
{
_stage = stage;
_facetType = facetType;
_atlas = atlas;
_shader = shader;
_expansionAmount = _facetType.expansionAmount;
_maxEmptyFacets = _facetType.maxEmptyAmount;
batchIndex = _facetType.index*10000000 + atlas.index*10000 + shader.index;
_gameObject = new GameObject("FRenderLayer ("+_stage.name+") ("+_facetType.name+")");
_transform = _gameObject.transform;
_transform.parent = Futile.instance.gameObject.transform;
_meshFilter = _gameObject.AddComponent<MeshFilter>();
_meshRenderer = _gameObject.AddComponent<MeshRenderer>();
//_meshRenderer.castShadows = false;
_meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
_meshRenderer.receiveShadows = false;
_mesh = _meshFilter.mesh;
_material = new Material(_shader.shader);
_material.mainTexture = _atlas.texture;
_meshRenderer.GetComponent<Renderer>().material = _material;
#if UNITY_3_0 || UNITY_3_1 || UNITY_3_2 || UNITY_3_3 || UNITY_3_4 || UNITY_3_5
_gameObject.active = false;
#else
_gameObject.SetActive(false);
_mesh.MarkDynamic();
#endif
ExpandMaxFacetLimit(_facetType.initialAmount);
UpdateTransform();
}
static Mesh GetOriginMeshFrom( SpriteRenderer spriteRenderer, MeshRenderer meshRenderer )
{
if ( spriteRenderer != null ) {
return SpriteMeshConstructor.ConstructFromRendererBounds( spriteRenderer );
} else {
return meshRenderer.GetComponent<MeshFilter>().mesh;
}
}
public RigidData(MeshRenderer mr)
{
var mf = mr.GetComponent<MeshFilter>();
if(mf == null)
throw new UnityException("Encountered MeshRenderer without matching MeshFilter! " + mr.name);
transform = mr.transform;
renderer = mr;
mesh = mf.sharedMesh;
materials = mr.sharedMaterials;
if(mesh == null || materials == null)
materials = new Material[0];
else if(materials.Length > mesh.subMeshCount) // Cut off any redundant materials in the renderer
System.Array.Resize(ref materials, mesh.subMeshCount);
props = new MaterialPropertyBlock();
props.AddMatrix(SID_PREV_MVP, Matrix4x4.identity);
prevWorld = transform.localToWorldMatrix;
}
void Awake()
{
Cursor = transform.Find("Cursor").gameObject;
CursorMeshRenderer = Cursor.transform.GetComponentInChildren<MeshRenderer>();
CursorMeshRenderer.GetComponent<Renderer>().material.color = new Color(0.0f, 0.8f, 1.0f);
}
public void Initialize() {
_primaryMeshRenderer = InitializePrimaryMesh(_trackedItemGo);
_primaryMeshRenderer.enabled = true;
var primaryMeshCameraLosChgdListener = _primaryMeshRenderer.GetComponent<ICameraLosChangedListener>();
primaryMeshCameraLosChgdListener.inCameraLosChanged += PrimaryMeshInCameraLosChangedEventHandler;
primaryMeshCameraLosChgdListener.enabled = true;
InitializeSecondaryMeshes(_trackedItemGo);
InitializeOther(_trackedItemGo);
// AssessComponentsToShow(); no need to call here as EnableDisplay(true) is called immediately after initialization
}
public static void componentSerialize(string ser)
{
GameObject gameObject = null;
MarkerFlag objMarker = deserializeMarkerFlag(ref ser);
int hashLoc = genHashCode(objMarker.id);
int xLoc = hashLoc % 10;
int yLoc = hashLoc % 100;
MarkerFlag thisFlag = findInList(objMarker.id, xLoc, yLoc);
if (thisFlag == null) //Make a new game object with given flag if you need to
{
gameObject = new GameObject();
thisFlag = gameObject.AddComponent <MarkerFlag>();
}
else
{
gameObject = thisFlag.gameObject;
}
thisFlag.id = objMarker.id;
thisFlag.parentID = objMarker.parentID;
thisFlag.isLocked = objMarker.isLocked;
if (thisFlag.parentID != "_")
{
int parentHash = genHashCode(thisFlag.parentID);
int xParent = parentHash % 10;
int yParent = parentHash % 100;
MarkerFlag parentFlag = findInList(thisFlag.parentID, xParent, yParent);
if (parentFlag != null)
{
gameObject.transform.SetParent(parentFlag.gameObject.transform);
}
else
{
gameObject.transform.SetParent(null);
}
}
else
{
gameObject.transform.SetParent(null);
}
gameObject.name = deserializeString(ref ser);
gameObject.tag = deserializeString(ref ser);
gameObject.layer = deserializeInt(ref ser);
gameObject.isStatic = deserializeBool(ref ser);
while (ser.Length > 0)
{
string tag = deserializeString(ref ser); //Identifies the component type
if (tag == "transform")
{
UnityEngine.Transform trans = gameObject.transform;
trans.position = deserializeVector3(ref ser);
trans.rotation = deserializeQuaternion(ref ser);
trans.localScale = deserializeVector3(ref ser);
if (expectedObjs > -1)
{
thisFlag.ogPos = trans.position;
thisFlag.ogRot = trans.rotation;
thisFlag.ogScale = trans.localScale;
}
}
else if (tag == "boxCollider")
{
UnityEngine.BoxCollider col = gameObject.GetComponent <UnityEngine.BoxCollider>();
if (col == null)
{
col = gameObject.AddComponent <UnityEngine.BoxCollider>();
}
col.center = deserializeVector3(ref ser);
col.size = deserializeVector3(ref ser);
col.isTrigger = deserializeBool(ref ser);
}
else if (tag == "sphereCollider")
{
UnityEngine.SphereCollider col = gameObject.GetComponent <UnityEngine.SphereCollider>();
if (col == null)
{
col = gameObject.AddComponent <UnityEngine.SphereCollider>();
}
col.center = deserializeVector3(ref ser);
col.radius = deserializeFloat(ref ser);
col.isTrigger = deserializeBool(ref ser);
}
else if (tag == "capsuleCollider")
{
UnityEngine.CapsuleCollider col = gameObject.GetComponent <UnityEngine.CapsuleCollider>();
if (col == null)
{
col = gameObject.AddComponent <UnityEngine.CapsuleCollider>();
}
col.center = deserializeVector3(ref ser);
col.radius = deserializeFloat(ref ser);
col.height = deserializeFloat(ref ser);
col.direction = deserializeInt(ref ser);
col.isTrigger = deserializeBool(ref ser);
}
else if (tag == "rigidbody")
{
UnityEngine.Rigidbody col = gameObject.GetComponent <UnityEngine.Rigidbody>();
if (col == null)
{
col = gameObject.AddComponent <UnityEngine.Rigidbody>();
}
col.mass = deserializeFloat(ref ser);
col.drag = deserializeFloat(ref ser);
col.angularDrag = deserializeFloat(ref ser);
col.interpolation = (RigidbodyInterpolation)deserializeInt(ref ser);
col.constraints = (RigidbodyConstraints)deserializeInt(ref ser);
col.useGravity = deserializeBool(ref ser);
col.isKinematic = deserializeBool(ref ser);
col.detectCollisions = deserializeBool(ref ser);
}
else if (tag == "camera")
{
UnityEngine.Camera cam = gameObject.GetComponent <UnityEngine.Camera>();
if (cam == null)
{
cam = gameObject.AddComponent <UnityEngine.Camera>();
}
cam.clearFlags = (CameraClearFlags)deserializeInt(ref ser);
cam.backgroundColor = deserializeColor(ref ser);
cam.cullingMask = deserializeInt(ref ser);
cam.nearClipPlane = deserializeFloat(ref ser);
cam.farClipPlane = deserializeFloat(ref ser);
cam.rect = deserializeRect(ref ser);
cam.renderingPath = (RenderingPath)deserializeInt(ref ser);
cam.allowHDR = deserializeBool(ref ser);
cam.allowMSAA = deserializeBool(ref ser);
cam.useOcclusionCulling = deserializeBool(ref ser);
cam.depth = deserializeFloat(ref ser);
cam.fieldOfView = deserializeFloat(ref ser);
cam.targetDisplay = deserializeInt(ref ser);
}
else if (tag == "light")
{
UnityEngine.Light li = gameObject.GetComponent <UnityEngine.Light>();
if (li == null)
{
li = gameObject.AddComponent <UnityEngine.Light>();
}
li.type = (LightType)deserializeInt(ref ser);
li.shadows = (LightShadows)deserializeInt(ref ser);
li.renderMode = (LightRenderMode)deserializeInt(ref ser);
li.cullingMask = deserializeInt(ref ser);
li.color = deserializeColor(ref ser);
li.intensity = deserializeFloat(ref ser);
li.cookieSize = deserializeFloat(ref ser);
}
else if (tag == "meshfilter")
{
UnityEngine.MeshFilter meshFilter = gameObject.GetComponent <UnityEngine.MeshFilter>();
if (meshFilter == null)
{
meshFilter = gameObject.AddComponent <UnityEngine.MeshFilter>();
}
string filePath = deserializeString(ref ser);
string meshName = deserializeString(ref ser);
UnityEngine.Object[] assets = AssetDatabase.LoadAllAssetsAtPath(filePath);
for (int x = 0; x < assets.Length; ++x)
{
if (assets[x].name == meshName)
{
gameObject.GetComponent <UnityEngine.MeshFilter>().mesh = assets[x] as UnityEngine.Mesh;
break;
}
}
}
else if (tag == "meshRenderer")
{
UnityEngine.MeshRenderer gOMeshRenderer = gameObject.GetComponent <UnityEngine.MeshRenderer>();
if (gOMeshRenderer == null)
{
gOMeshRenderer = gameObject.AddComponent <UnityEngine.MeshRenderer>();
}
gOMeshRenderer.lightProbeUsage = (UnityEngine.Rendering.LightProbeUsage)deserializeInt(ref ser);
gOMeshRenderer.reflectionProbeUsage = (UnityEngine.Rendering.ReflectionProbeUsage)deserializeInt(ref ser);
gOMeshRenderer.shadowCastingMode = (UnityEngine.Rendering.ShadowCastingMode)deserializeInt(ref ser);
gOMeshRenderer.receiveShadows = deserializeBool(ref ser);
gOMeshRenderer.motionVectorGenerationMode = (UnityEngine.MotionVectorGenerationMode)deserializeInt(ref ser);
//Light map static junk
deserializeBool(ref ser);
string materialsList = deserializeString(ref ser);
List <Material> renderMaterials = new List <Material>();
if (materialsList.Length > 1)
{
while (materialsList != "")
{
int length = materialsList.IndexOf(",");
if (length > 0)
{
string ret = materialsList.Substring(0, length);
materialsList = materialsList.Remove(0, length + 1);
Material newMat = null;
if (ret == "Default-Material" || ret == "" || ret == "Resources/unity_builtin_extra")
{
newMat = AssetDatabase.GetBuiltinExtraResource <Material>("Default-Diffuse.mat");
}
else
{
newMat = (Material)AssetDatabase.LoadAssetAtPath(ret, typeof(Material));
}
renderMaterials.Add(newMat);
}
}
if (renderMaterials.Count > 0)
{
gOMeshRenderer.GetComponent <Renderer>().materials = renderMaterials.ToArray();
}
}
}
else if (tag == "guilayer")
{
UnityEngine.GUILayer gOGuiLayer = gameObject.GetComponent <GUILayer>();
if (gOGuiLayer == null)
{
gOGuiLayer = gameObject.AddComponent <GUILayer>();
}
}
else if (tag == "flarelayer")
{
UnityEngine.FlareLayer gOFlareLayer = gameObject.GetComponent <FlareLayer>();
if (gOFlareLayer == null)
{
gOFlareLayer = gameObject.AddComponent <FlareLayer>();
}
}
else if (tag == "audiolistener")
{
UnityEngine.AudioListener gOAudioListener = gameObject.GetComponent <AudioListener>();
if (gOAudioListener == null)
{
gOAudioListener = gameObject.AddComponent <AudioListener>();
}
}
else
{
Debug.Log("Unkown Componenet Type " + tag);
}
}
addToMap(thisFlag);
}
//--------------------------------------------------------------
// End utility functions
//--------------------------------------------------------------
void Awake()
{
gameObject.AddComponent<MeshFilter>();
gameObject.AddComponent<MeshRenderer>();
meshFilter = (MeshFilter)GetComponent(typeof(MeshFilter));
meshRenderer = (MeshRenderer)GetComponent(typeof(MeshRenderer));
meshRenderer.GetComponent<Renderer>().material = material;
mesh = meshFilter.mesh;
// Create our first batch of sprites:
EnlargeArrays(allocBlockSize);
// Move the object to the origin so the objects drawn will not
// be offset from the objects they are intended to represent.
transform.position = Vector3.zero;
transform.rotation = Quaternion.identity;
}
// Use this for initialization
void Start () {
mapManager = MapManager.Instance;
tileMesh = tileObject.GetComponentInChildren<MeshRenderer>();
if (tileMesh == null) {
Debug.LogError ("tile mesh not found", tileMesh);
return;
}
if(_debugTile)
{
posText.gameObject.SetActive(true);
coordText.gameObject.SetActive(true);
}
else
{
posText.gameObject.SetActive(false);
coordText.gameObject.SetActive(false);
}
//Material newMat = hexMaterials[Mathf.RoundToInt(Random.Range(0, hexMaterials.Length))];
//tileMesh.material = newMat;
defaultColor = tileMesh.GetComponent<Renderer>().material.color;
}
