public FRenderLayer(FStage stage, FAtlas atlas, FShader shader)
{
_stage = stage;
_atlas = atlas;
_shader = shader;
_expansionAmount = Futile.quadsPerLayerExpansion;
_maxEmptyQuads = Futile.maxEmptyQuadsPerLayer;
batchIndex = atlas.index*10000 + shader.index;
_gameObject = new GameObject("FRenderLayer ("+_stage.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;
_material = new Material(_shader.shader);
_material.mainTexture = _atlas.texture;
_meshRenderer.renderer.material = _material;
_gameObject.active = false;
ExpandMaxQuadLimit(Futile.startingQuadsPerLayer);
UpdateTransform();
}
//called by Futile
public static void Init()
{
Normal = new FShader("Normal", Shader.Find("Unlit Transparent Vertex Colored"), nextShaderIndex++);
Additive = new FShader("Additive", Shader.Find("Unlit Transparent Vertex Colored Additive"), nextShaderIndex++);
defaultShader = Normal;
}
public FRenderLayer(FAtlas atlas, FShader shader)
{
_atlas = atlas;
_shader = shader;
_expansionAmount = Futile.quadsPerLayerExpansion;
_maxEmptyQuads = Futile.maxEmptyQuadsPerLayer;
batchIndex = atlas.index * 10000 + shader.index;
_gameObject = new GameObject("FRenderLayer");
_gameObject.transform.parent = Futile.instance.gameObject.transform;
_meshFilter = _gameObject.AddComponent <MeshFilter>();
_meshRenderer = _gameObject.AddComponent <MeshRenderer>();
_meshRenderer.castShadows = false;
_meshRenderer.receiveShadows = false;
_mesh = _meshFilter.mesh;
_material = new Material(_shader.shader);
_material.mainTexture = _atlas.texture;
_meshRenderer.renderer.material = _material;
_gameObject.active = false;
ExpandMaxQuadLimit(Futile.startingQuadsPerLayer);
}
public static void Init() //called by Futile
{
Normal = new FShader("Normal", Shader.Find("Unlit Transparent Vertex Colored"), nextShaderIndex++);
Additive = new FShader("Additive", Shader.Find("Unlit Transparent Vertex Colored Additive"), nextShaderIndex++);
defaultShader = Normal;
}
protected void Init(FAtlasElement element, int numberOfQuadsNeeded)
{
_element = element;
_shader = FShader.defaultShader;
_numberOfQuadsNeeded = numberOfQuadsNeeded;
HandleElementChanged();
}
public static void Init() //called by Futile
{
Normal = CreateShader("Normal", Shader.Find("Unlit Transparent Vertex Colored"));
Additive = CreateShader("Additive", Shader.Find("Unlit Transparent Vertex Colored Additive"));
AdditiveColor = CreateShader("AdditiveColor", Shader.Find("Unlit Transparent Vertex Colored Additive Color"));
Solid = CreateShader("Solid", Shader.Find("Unlit Transparent Vertex Colored Solid"));
defaultShader = Normal;
}
//called by Futile
public static void Init()
{
Normal = CreateShader("Normal", Shader.Find("Unlit Transparent Vertex Colored"));
Additive = CreateShader("Additive", Shader.Find("Unlit Transparent Vertex Colored Additive"));
AdditiveColor = CreateShader("AdditiveColor", Shader.Find("Unlit Transparent Vertex Colored Additive Color"));
Solid = CreateShader("Solid", Shader.Find("Unlit Transparent Vertex Colored Solid"));
defaultShader = Normal;
}
public void Init(FutileParams futileParams)
{
enabled = true;
_futileParams = futileParams;
Application.targetFrameRate = _futileParams.targetFrameRate;
FShader.Init(); //set up the basic shaders
FFacetType.Init(); //set up the types of facets (Quads, Triangles, etc)
screen = new FScreen(_futileParams);
//
//Camera setup from https://github.com/prime31/UIToolkit/blob/master/Assets/Plugins/UIToolkit/UI.cs
//
if (existingCamera != null)
{
_cameraHolder = existingCamera.gameObject;
_camera = existingCamera;
}
else
{
_cameraHolder = new GameObject();
_camera = _cameraHolder.AddComponent <Camera>();
}
_cameraHolder.transform.parent = gameObject.transform;
_camera.tag = "MainCamera";
_camera.clearFlags = CameraClearFlags.SolidColor;
_camera.nearClipPlane = 0.0f;
_camera.farClipPlane = 500.0f;
_camera.depth = 100;
_camera.rect = new Rect(0.0f, 0.0f, 1.0f, 1.0f);
_camera.backgroundColor = _futileParams.backgroundColor;
//we multiply this stuff by scaleInverse to make sure everything is in points, not pixels
_camera.orthographic = true;
_camera.orthographicSize = screen.pixelHeight / 2 * displayScaleInverse;
UpdateCameraPosition();
touchManager = new FTouchManager();
atlasManager = new FAtlasManager();
CreateDefaultAtlases();
_stages = new List <FStage>();
stage = new FStage("Futile.stage");
AddStage(stage);
}
public FTilemap(string elementBase) : base()
{
_baseName = elementBase;
_tiles = new List <FSprite>();
_shader = FShader.defaultShader;
this.ListenForUpdate(Update);
}
//called by Futile
public static void Init()
{
Basic = CreateShader("Basic", Shader.Find("Futile/Basic"));
Additive = CreateShader("Additive", Shader.Find("Futile/Additive"));
AdditiveColor = CreateShader("AdditiveColor", Shader.Find("Futile/AdditiveColor"));
Solid = CreateShader("Solid", Shader.Find("Futile/Solid"));
SolidColored = CreateShader("SolidColored", Shader.Find("Futile/SolidColored"));
defaultShader = Basic;
}
//called by Futile
public static void Init()
{
Normal = CreateShader("Normal", Shader.Find("Futile/Normal"));
Additive = CreateShader("Additive", Shader.Find("Futile/Additive"));
AdditiveColor = CreateShader("AdditiveColor", Shader.Find("Futile/AdditiveColor"));
Solid = CreateShader("Solid", Shader.Find("Futile/Solid"));
SolidColored = CreateShader("SolidColored", Shader.Find("Futile/SolidColored"));
defaultShader = Normal;
}
//FShader初始化
public static void Init() //called by Futile
{
Basic = CreateShader("Basic", Shader.Find("Futile/Basic"));
Additive = CreateShader("Additive", Shader.Find("Futile/Additive"));
AdditiveColor = CreateShader("AdditiveColor", Shader.Find("Futile/AdditiveColor"));
Solid = CreateShader("Solid", Shader.Find("Futile/Solid"));
SolidColored = CreateShader("SolidColored", Shader.Find("Futile/SolidColored"));
defaultShader = Basic;
}
public FTilemap (string elementBase) : base()
{
_baseName = elementBase;
_tiles = new List<FSprite> ();
_shader = FShader.defaultShader;
this.ListenForUpdate (Update);
}
virtual protected void Init(FFacetType facetType, FAtlas atlas, int numberOfFacetsNeeded)
{
_facetType = facetType;
_atlas = atlas;
if(_shader == null) _shader = FShader.defaultShader;
_numberOfFacetsNeeded = numberOfFacetsNeeded;
_hasInited = true;
}
public ChunkRenderer(Chunk chunk)
{
_chunk = chunk;
_drawTiles = new List <Tile>();
_tilesQueue = new Queue <Tile>();
_showing = false;
_initialized = false;
_shader = IsometricMain.GetShader("WorldObject");
}
public static void Init() //called by Futile
{
Basic = new FShader("Basic", Shader.Find("Futile/Basic"));
Additive = new FShader("Additive", Shader.Find("Futile/Additive"));
AdditiveColor = new FShader("AdditiveColor", Shader.Find("Futile/AdditiveColor"));
Solid = new FShader("Solid", Shader.Find("Futile/Solid"));
SolidColored = new FShader("SolidColored", Shader.Find("Futile/SolidColored"));
Basic_PixelSnap = new FShader("Basic_PixelSnap", Shader.Find("Futile/Basic_PixelSnap"));
MaskedShader = new FShader("Masked", Shader.Find("Futile/Masked"));
defaultShader = Basic;
}
//create your own FShaders by creating them here
public static FShader CreateShader(string shaderShortName, Shader shader)
{
for(int s = 0; s<_shaders.Count; s++)
{
if(_shaders[s].name == shaderShortName) return _shaders[s]; //don't add it if we have it already
}
FShader newShader = new FShader(shaderShortName, shader, _nextShaderIndex++);
_shaders.Add (newShader);
return newShader;
}
//called by Futile
public static void Init()
{
Basic = new FShader("Basic", Shader.Find("Futile/Basic"));
Additive = new FShader("Additive", Shader.Find("Futile/Additive"));
AdditiveColor = new FShader("AdditiveColor", Shader.Find("Futile/AdditiveColor"));
Solid = new FShader("Solid", Shader.Find("Futile/Solid"));
SolidColored = new FShader("SolidColored", Shader.Find("Futile/SolidColored"));
Basic_PixelSnap = new FShader("Basic_PixelSnap", Shader.Find("Futile/Basic_PixelSnap"));
defaultShader = Basic;
}
protected void Init(FFacetType facetType, FAtlasElement element, int numberOfFacetsNeeded)
{
_facetType = facetType;
_element = element;
if (_shader == null)
{
_shader = FShader.defaultShader;
}
_numberOfFacetsNeeded = numberOfFacetsNeeded;
HandleElementChanged();
}
public static void Init() //called by Futile
{
Basic = new FShader("Basic", Shader.Find("Futile/Basic"));
Additive = new FShader("Additive", Shader.Find("Futile/Additive"));
AdditiveColor = new FShader("AdditiveColor", Shader.Find("Futile/AdditiveColor"));
Solid = new FShader("Solid", Shader.Find("Futile/Solid"));
SolidColored = new FShader("SolidColored", Shader.Find("Futile/SolidColored"));
Basic_PixelSnap = new FShader("Basic_PixelSnap", Shader.Find("Futile/Basic_PixelSnap"));
OverlayBlend = new FOverlayBlendShader();
defaultShader = OverlayBlend;
}
public CosmeticRenderer(FAtlasElement element)
{
_element = element;
_worldPosition = Vector3.zero;
_positionOffset = Vector2.zero;
_rotation = 0f;
_doesFlip = true;
_viewAngle = 0f;
_sortZOffset = 0f;
_color = Color.white;
_scale = Vector2.one;
_shader = FShader.defaultShader;
}
virtual protected void Init(FFacetType facetType, FAtlas atlas, int numberOfFacetsNeeded)
{
_facetType = facetType;
_atlas = atlas;
if (_shader == null)
{
_shader = FShader.defaultShader;
}
_numberOfFacetsNeeded = numberOfFacetsNeeded;
_hasInited = true;
}
public void Init(FutileParams futileParams)
{
enabled = true;
_futileParams = futileParams;
//设置游戏帧率
Application.targetFrameRate = _futileParams.targetFrameRate;
//设置basic shaders
FShader.Init();
//设置facets' types (Quads, Triangles, etc)
FFacetType.Init();
//初始化各引擎组件实例
screen = new FScreen(_futileParams);
touchManager = new FTouchManager();
atlasManager = new FAtlasManager();
//设置主相机参数：Setup from https://github.com/prime31/UIToolkit/blob/master/Assets/Plugins/UIToolkit/UI.cs
_cameraHolder = new GameObject();
_cameraHolder.transform.parent = gameObject.transform;
_camera = _cameraHolder.AddComponent <Camera>();
_camera.tag = "MainCamera";
_camera.name = "Camera";
//_camera.clearFlags = CameraClearFlags.Depth; //TODO: check if this is faster or not?
_camera.clearFlags = CameraClearFlags.SolidColor;
_camera.nearClipPlane = 0.0f;
_camera.farClipPlane = 500.0f;
_camera.depth = 100;
_camera.rect = new Rect(0.0f, 0.0f, 1.0f, 1.0f);
_camera.backgroundColor = _futileParams.backgroundColor;
//we multiply this stuff by scaleInverse to make sure everything is in points, not pixels
_camera.orthographic = true;
_camera.orthographicSize = screen.pixelHeight / 2 * displayScaleInverse;
UpdateCameraPosition();
//创建默认Atlas
CreateDefaultAtlases();
//初始化Stage管理
_stages = new List <FStage>();
stage = new FStage("Futile.stage");
AddStage(stage);
}
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>();
// warning CS0618: `UnityEngine.Renderer.castShadows' is obsolete: `Property castShadows has been deprecated. Use shadowCastingMode instead.'
// UNITY5 UPDATE: http://docs.unity3d.com/ScriptReference/MeshRenderer.html
// http://docs.unity3d.com/ScriptReference/Renderer-shadowCastingMode.html
// http://docs.unity3d.com/ScriptReference/Rendering.ShadowCastingMode.html
//_meshRenderer.castShadows = false;
_meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
_meshRenderer.receiveShadows = false;
_meshRenderer.useLightProbes = false;
_meshRenderer.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off;
_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();
}
private void LoadShaders()
{
_shaders = new Dictionary <string, FShader>();
FShader[] array = new FShader[]
{
FShader.CreateShader("WorldObject", Resources.Load <Shader>("Shaders/WorldObject")),
FShader.CreateShader("DroppedItem", Resources.Load <Shader>("Shaders/DroppedItem"))
};
foreach (var shader in array)
{
_shaders.Add(shader.name, shader);
}
}
public void Init(FutileParams futileParams)
{
enabled = true;
_futileParams = futileParams;
Application.targetFrameRate = _futileParams.targetFrameRate;
FShader.Init(); //set up the basic shaders
Futile.startingQuadsPerLayer = _futileParams.startingQuadsPerLayer;
Futile.quadsPerLayerExpansion = _futileParams.quadsPerLayerExpansion;
Futile.maxEmptyQuadsPerLayer = _futileParams.maxEmptyQuadsPerLayer;
screen = new FScreen(_futileParams);
//
//Camera setup from https://github.com/prime31/UIToolkit/blob/master/Assets/Plugins/UIToolkit/UI.cs
//
_cameraHolder = new GameObject();
_cameraHolder.transform.parent = gameObject.transform;
_camera = _cameraHolder.AddComponent <Camera>();
_camera.name = "Camera";
//_camera.clearFlags = CameraClearFlags.Depth; //TODO: check if this is faster or not?
_camera.clearFlags = CameraClearFlags.SolidColor;
_camera.nearClipPlane = -50.0f;
_camera.farClipPlane = 50.0f;
_camera.depth = 100;
_camera.rect = new Rect(0.0f, 0.0f, 1.0f, 1.0f);
_camera.backgroundColor = _futileParams.backgroundColor;
//we multiply this stuff by scaleInverse to make sure everything is in points, not pixels
_camera.orthographic = true;
_camera.orthographicSize = screen.pixelHeight / 2 * displayScaleInverse;
UpdateCameraPosition();
touchManager = new FTouchManager();
atlasManager = new FAtlasManager();
_stages = new List <FStage>();
stage = new FStage("Futile.stage");
AddStage(stage);
}
//创建FShader的唯一接口
//create your own FShaders by creating them here
public static FShader CreateShader(string shaderShortName, Shader shader)
{
for (int s = 0; s < _shaders.Count; s++)
{
if (_shaders[s].name == shaderShortName)
{
return(_shaders[s]); //don't add it if we have it already
}
}
FShader newShader = new FShader(shaderShortName, shader, _nextShaderIndex++);
_shaders.Add(newShader);
return(newShader);
}
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 + ")");
//Esteban.
_gameObject.layer = 11;
_stage.layer = 11;
_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;
_material = new Material(_shader.shader);
_material.mainTexture = _atlas.texture;
_meshRenderer.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();
}
public LOSController(Room room)
{
_x = 0;
_y = 0;
if (_fovShader == null)
{
Material mat = new Material(Shaders.LevelOutOfFOV);
_fovShader = FShader.CreateShader("LevelOutOfFOV", mat.shader);
}
_shader = LineOfSightMod.classic ? room.game.rainWorld.Shaders["Basic"] : _fovShader;
// Create a copy of the room's tiles
Room.Tile[,] fromTiles = (Room.Tile[, ])_Room_Tiles.GetValue(room);
_tiles = new Room.Tile[fromTiles.GetLength(0), fromTiles.GetLength(1)];
Array.Copy(fromTiles, _tiles, fromTiles.Length);
}
protected FRenderLayer CreateRenderLayer(int batchIndex, FAtlas atlas, FShader shader)
{
//first, check and see if we already have a layer that matches the batchIndex
int previousLiveLayerCount = _previousLiveLayers.Count;
for (int p = 0; p < previousLiveLayerCount; ++p)
{
FRenderLayer previousLiveLayer = _previousLiveLayers[p];
if (previousLiveLayer.batchIndex == batchIndex)
{
_previousLiveLayers.RemoveAt(p);
_liveLayers.Add(previousLiveLayer);
previousLiveLayer.depth = _depthToUse++;
return(previousLiveLayer);
}
}
//now see if we have a cached (old, now unused layer) that matches the batchIndex
int cachedLayerCount = _cachedLayers.Count;
for (int c = 0; c < cachedLayerCount; ++c)
{
FRenderLayer cachedLayer = _cachedLayers[c];
if (cachedLayer.batchIndex == batchIndex)
{
_cachedLayers.RemoveAt(c);
cachedLayer.AddToWorld();
_liveLayers.Add(cachedLayer);
cachedLayer.depth = _depthToUse++;
return(cachedLayer);
}
}
//still no layer found? create a new one!
FRenderLayer newLayer = new FRenderLayer(_stage, atlas, shader);
_liveLayers.Add(newLayer);
_allLayers.Add(newLayer);
newLayer.AddToWorld();
newLayer.depth = _depthToUse++;
return(newLayer);
}
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.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)
{
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)
{
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;
_material = new Material(shader.shader);
_material.mainTexture = atlas.texture;
_meshRenderer.renderer.sharedMaterial = _material;
//_meshRenderer.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();
}
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();
}
protected FFacetRenderLayer CreateFacetRenderLayer(FFacetType facetType, int batchIndex, FAtlas atlas, FShader shader)
{
//first, check and see if we already have a layer that matches the batchIndex
int previousLiveLayerCount = _previousLiveLayers.Count;
for(int p = 0; p<previousLiveLayerCount; ++p)
{
FFacetRenderLayer previousLiveLayer = _previousLiveLayers[p];
if(previousLiveLayer.batchIndex == batchIndex)
{
_previousLiveLayers.RemoveAt(p);
_liveLayers.Add (previousLiveLayer);
_allRenderables.Add(previousLiveLayer);
return previousLiveLayer;
}
}
//now see if we have a cached (old, now unused layer) that matches the batchIndex
int cachedLayerCount = _cachedLayers.Count;
for(int c = 0; c<cachedLayerCount; ++c)
{
FFacetRenderLayer cachedLayer = _cachedLayers[c];
if(cachedLayer.batchIndex == batchIndex)
{
_cachedLayers.RemoveAt(c);
cachedLayer.AddToWorld();
_liveLayers.Add (cachedLayer);
_allRenderables.Add(cachedLayer);
return cachedLayer;
}
}
//still no layer found? create a new one!
FFacetRenderLayer newLayer = facetType.createRenderLayer(_stage, facetType,atlas,shader);
_liveLayers.Add(newLayer);
_allLayers.Add(newLayer);
_allRenderables.Add(newLayer);
newLayer.AddToWorld();
return newLayer;
}
public void GetRenderLayer(ref FRenderLayer renderLayer, ref int firstQuadIndex, FAtlas atlas, FShader shader, int numberOfQuadsNeeded)
{
int batchIndex = atlas.index*10000 + shader.index;
if(_topLayer == null)
{
_topLayer = CreateRenderLayer(batchIndex, atlas, shader);
_topLayer.Open();
}
else
{
if(_topLayer.batchIndex != batchIndex) //we're changing layers!
{
_topLayer.Close(); //close the old layer
_topLayer = CreateRenderLayer(batchIndex, atlas, shader);
_topLayer.Open(); //open the new layer
}
}
renderLayer = _topLayer;
firstQuadIndex = _topLayer.GetNextQuadIndex(numberOfQuadsNeeded);
}
public void GetFacetRenderLayer(out FFacetRenderLayer renderLayer, out int firstFacetIndex, FFacetType facetType, FAtlas atlas, FShader shader, int numberOfFacetsNeeded)
{
int batchIndex = facetType.index*10000000 + atlas.index*10000 + shader.index;
if(_topLayer == null)
{
_topLayer = CreateFacetRenderLayer(facetType, batchIndex, atlas, shader);
_topLayer.Open();
}
else
{
if(_topLayer.batchIndex != batchIndex) //we're changing layers!
{
_topLayer.Close(); //close the old layer
_topLayer = CreateFacetRenderLayer(facetType, batchIndex, atlas, shader);
_topLayer.Open(); //open the new layer
}
}
renderLayer = _topLayer;
firstFacetIndex = _topLayer.GetNextFacetIndex(numberOfFacetsNeeded);
}
public FRenderLayer(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.receiveShadows = false;
_mesh = _meshFilter.mesh;
_material = new Material(_shader.shader);
_material.mainTexture = _atlas.texture;
_meshRenderer.renderer.material = _material;
_gameObject.active = false;
ExpandMaxFacetLimit(_facetType.initialAmount);
UpdateTransform();
}
protected void Init(FFacetType facetType, FAtlasElement element, int numberOfFacetsNeeded)
{
_facetType = facetType;
_element = element;
if(_shader == null) _shader = FShader.defaultShader;
_numberOfFacetsNeeded = numberOfFacetsNeeded;
HandleElementChanged();
}
//called by the FRenderer
public static void Init()
{
Normal = new FShader("Normal", Shader.Find("Unlit Transparent Vertex Colored"));
Additive = new FShader("Additive", Shader.Find("Unlit Transparent Vertex Colored Additive"));
}
protected void Init(FAtlasElement element, int numberOfQuadsNeeded)
{
_element = element;
_shader = _stage.renderer.GetDefaultShader();
_numberOfQuadsNeeded = numberOfQuadsNeeded;
}
public FTriangleRenderLayer(FStage stage, FFacetType facetType, FAtlas atlas, FShader shader) : base(stage, facetType, atlas, shader)
{
}
public static void Init() //called by the FRenderer
{
Normal = new FShader("Normal", Shader.Find("Unlit Transparent Vertex Colored"));
Additive = new FShader("Additive", Shader.Find("Unlit Transparent Vertex Colored Additive"));
}
static private FFacetRenderLayer CreateQuadLayer(FStage stage, FFacetType facetType, FAtlas atlas, FShader shader)
{
return(new FQuadRenderLayer(stage, facetType, atlas, shader));
}
private static FRenderLayer CreateTriLayer(FStage stage, FFacetType facetType, FAtlas atlas, FShader shader)
{
return new FRenderTriangleLayer(stage,facetType,atlas,shader);
}
public FTriangleRenderLayer(FStage stage, FFacetType facetType, FAtlas atlas, FShader shader)
: base(stage,facetType,atlas,shader)
{
}
public void GetRenderLayer(ref FRenderLayer renderLayer, ref int firstQuadIndex, FAtlas atlas, FShader shader, int numberOfQuadsNeeded)
{
int batchIndex = atlas.index * 10000 + shader.index;
if (_topLayer == null)
{
_topLayer = CreateRenderLayer(batchIndex, atlas, shader);
_topLayer.Open();
}
else
{
if (_topLayer.batchIndex != batchIndex) //we're changing layers!
{
_topLayer.Close(); //close the old layer
_topLayer = CreateRenderLayer(batchIndex, atlas, shader);
_topLayer.Open(); //open the new layer
}
}
renderLayer = _topLayer;
firstQuadIndex = _topLayer.GetNextQuadIndex(numberOfQuadsNeeded);
}
static private FFacetRenderLayer CreateTriLayer(FStage stage, FFacetType facetType, FAtlas atlas, FShader shader)
{
return(new FTriangleRenderLayer(stage, facetType, atlas, shader));
}
private static void MenuScene_BuildScene(On.Menu.MenuScene.orig_BuildScene orig, MenuScene self)
{
// Automatically override scenes if the current character has a scene by the same name
SlugBaseCharacter currentPlayer;
if (PlayerManager.UsingCustomCharacter)
{
currentPlayer = PlayerManager.CurrentCharacter;
}
else
{
int index;
if (self.menu.manager.currentMainLoop is RainWorldGame rwg)
{
index = rwg.StoryCharacter;
}
else
{
index = self.menu.manager.rainWorld.progression.PlayingAsSlugcat;
}
currentPlayer = PlayerManager.GetCustomPlayer(index);
}
if (currentPlayer != null)
{
string sceneName = self.sceneID.ToString();
if (sceneOverride == null && currentPlayer.HasScene(sceneName))
{
OverrideNextScene(currentPlayer, sceneName);
}
}
if (sceneOverride != null)
{
try
{
self.sceneFolder = resourceFolderName;
// Check for flatmode support
bool hasFlatmode = false;
foreach (var img in sceneOverride.Images)
{
if (img.HasTag("FLATMODE"))
{
hasFlatmode = true;
break;
}
}
// Load all images into the scene
for (int imgIndex = 0; imgIndex < sceneOverride.Images.Count; imgIndex++)
{
var img = sceneOverride.Images[imgIndex];
// Hide disabled images
if (!img.Enabled)
{
continue;
}
// Allow images to use their own sprites
if (!img.OnBuild(self))
{
continue;
}
// Skip this image if it is flatmode only and flatmode is disabled, and vice versa
bool flat = img.depth < 0f;
bool flatmodeOnly = hasFlatmode && img.HasTag("flatmode");
if (hasFlatmode && (self.flatMode != flatmodeOnly))
{
continue;
}
// Parse alpha
float alpha = img.GetProperty <float?>("alpha") ?? 1f;
string assetPath = $"{sceneOverride.Owner.Name}\\Scenes\\{sceneOverride.Name}\\{img.assetName}";
Vector2 pos = img.Pos;
bool crisp = img.HasTag("CRISP");
string shaderName = img.GetProperty <string>("shader");
FShader shader = null;
MenuIllustration illust;
if (flat)
{
// It's Friday
// Parse shader
if (shaderName != null)
{
if (!self.menu.manager.rainWorld.Shaders.TryGetValue(shaderName, out shader))
{
shader = null;
}
}
// Add a flat illustration
illust = new MenuIllustration(self.menu, self, self.sceneFolder, assetPath, pos, crisp, false);
if (shader != null)
{
illust.sprite.shader = shader;
}
}
else
{
// Parse shader
MenuDepthIllustration.MenuShader menuShader = MenuDepthIllustration.MenuShader.Normal;
if (shaderName != null)
{
try
{
menuShader = Custom.ParseEnum <MenuDepthIllustration.MenuShader>(shaderName);
shader = null;
}
catch
{
if (!self.menu.manager.rainWorld.Shaders.TryGetValue(shaderName, out shader))
{
shader = null;
}
menuShader = MenuDepthIllustration.MenuShader.Normal;
}
}
// Add an illustration with depth
illust = new MenuDepthIllustration(self.menu, self, self.sceneFolder, assetPath, pos, img.Depth, menuShader);
// Apply crisp pixels
if (crisp)
{
illust.sprite.element.atlas.texture.filterMode = FilterMode.Point;
}
}
// Add idle depths
if (self is InteractiveMenuScene ims)
{
ims.idleDepths = new List <float>();
List <object> depths = sceneOverride.GetProperty <List <object> >("idledepths");
if (depths != null)
{
for (int i = 0; i < depths.Count; i++)
{
if (depths[i] is double depth)
{
ims.idleDepths.Add((float)depth);
}
}
}
}
// Apply tags
if (shader != null)
{
illust.sprite.shader = shader;
}
illust.setAlpha = alpha;
self.AddIllustration(illust);
// Link back to the custom scene image
customRep[illust] = img;
}
}
finally { ClearSceneOverride(); }
}
else
{
orig(self);
}
}
static private FFacetRenderLayer CreateQuadLayer(FStage stage, FFacetType facetType, FAtlas atlas, FShader shader)
{
return new FQuadRenderLayer(stage,facetType,atlas,shader);
}
//获取Facet渲染层级
public void GetFacetRenderLayer(out FFacetRenderLayer renderLayer, out int firstFacetIndex, FFacetType facetType, FAtlas atlas, FShader shader, int numberOfFacetsNeeded)
{
int batchIndex = facetType.index * 10000000 + atlas.index * 10000 + shader.index;
if (_topLayer == null)
{
_topLayer = CreateFacetRenderLayer(facetType, batchIndex, atlas, shader);
_topLayer.Open();
}
else
{
if (_topLayer.batchIndex != batchIndex) //we're changing layers!
{
_topLayer.Close(); //close the old layer
_topLayer = CreateFacetRenderLayer(facetType, batchIndex, atlas, shader);
_topLayer.Open(); //open the new layer
}
}
renderLayer = _topLayer;
firstFacetIndex = _topLayer.GetNextFacetIndex(numberOfFacetsNeeded);
}
public FRenderQuadLayer(FStage stage, FFacetType facetType, FAtlas atlas, FShader shader)
: base(stage,facetType,atlas,shader)
{
}
protected void Init(FAtlasElement element, int numberOfQuadsNeeded)
{
_element = element;
_shader = FShader.defaultShader;
_numberOfQuadsNeeded = numberOfQuadsNeeded;
HandleElementChanged();
}
protected FRenderLayer CreateRenderLayer(int batchIndex, FAtlas atlas, FShader shader)
{
//first, check and see if we already have a layer that matches the batchIndex
for(int p = 0; p < _previousLiveLayers.Count; ++p)
{
FRenderLayer previousLiveLayer = _previousLiveLayers[p];
if(previousLiveLayer.batchIndex == batchIndex)
{
_previousLiveLayers.RemoveAt(p);
_liveLayers.Add (previousLiveLayer);
previousLiveLayer.depth = _depthToUse++;
return previousLiveLayer;
}
}
//now see if we have a cached (old, now unused layer) that matches the batchIndex
for(int c = 0; c< _cachedLayers.Count; ++c)
{
FRenderLayer cachedLayer = _cachedLayers[c];
if(cachedLayer.batchIndex == batchIndex)
{
_cachedLayers.RemoveAt(c);
cachedLayer.AddToWorld();
_liveLayers.Add (cachedLayer);
cachedLayer.depth = _depthToUse++;
return cachedLayer;
}
}
//still no layer found? create a new one!
FRenderLayer newLayer = new FRenderLayer(atlas,shader);
_liveLayers.Add(newLayer);
newLayer.AddToWorld();
newLayer.depth = _depthToUse++;
return newLayer;
}
public FRenderer()
{
FShader.Init();
}
//called by Futile
public static void Init()
{
Blur = new FBlurShader(0.003f);
Test = new FTestShader();
Glow = new FGlowShader(0.001f,new Color(1,1,1,0));
}
