// Default Constructor
public Light()
: base()
{
red = green = blue = 255.0f;
intensity = radius = 0.0f;
type = LightType.Point;
}
/// <summary>
/// Initializes a new instance of the <see cref="Light"/> class.
/// </summary>
public Light()
{
_CastShadows = true;
_Enabled = true;
_Range = 20;
_Type = LightType.Point;
}
/// <summary>
/// Constructor or added a new light to the scene
/// </summary>
/// <param name="type">the light type you wish to have or default of point</param>
public LightClass(LightType type = LightType.Point)
{
if (type == LightType.Point)
{
light.Type = type;
light.Diffuse = Color.White;
light.Ambient = Color.White;
light.Specular = Color.White;
light.Position = Vector3.Zero;
light.Range = 100.0f;
}
else if (type == LightType.Directional)
{
light.Type = type;
light.Direction = Vector3.Zero;
light.Ambient = Color.White;
light.Diffuse = Color.White;
light.Specular = Color.White;
light.Range = 100.0f;
}
isLightEnabled = false;
Type = type.ToString();
Position = Vector3.Zero;
Direction = Vector3.Zero;
world = Matrix.Identity;
mesh = Mesh.CreateSphere(DeviceManager.LocalDevice, .1f, 10, 10);
material.Diffuse = Color.White;
material.Ambient = Color.White;
DeviceManager.LocalDevice.Material = material;
}
public Light(LightType type, Vector3D p1, Vector3D p2, Vector3D p3, Color3D color)
{
Type = type;
Color = color;
_grid = new Vector3D[16];
_grid[0] = new Vector3D(1, 2, 0);
_grid[1] = new Vector3D(3, 3, 0);
_grid[2] = new Vector3D(2, 0, 0);
_grid[3] = new Vector3D(0, 1, 0);
_grid[4] = new Vector3D(2, 3, 0);
_grid[5] = new Vector3D(0, 3, 0);
_grid[6] = new Vector3D(0, 0, 0);
_grid[7] = new Vector3D(2, 2, 0);
_grid[8] = new Vector3D(3, 1, 0);
_grid[9] = new Vector3D(1, 3, 0);
_grid[10] = new Vector3D(1, 0, 0);
_grid[11] = new Vector3D(3, 2, 0);
_grid[12] = new Vector3D(2, 1, 0);
_grid[13] = new Vector3D(3, 0, 0);
_grid[14] = new Vector3D(1, 1, 0);
_grid[15] = new Vector3D(0, 2, 0);
CellX = (p2 - p1) * .25f;
CellY = (p3 - p1) * .25f;
for (int i = 0; i < 16; i++)
_grid[i] = _grid[i][0] * CellX + _grid[i][1] * CellY + p1;
Position = p1 + 2 * CellX + 2 * CellY;
}
public Light(Color _color, float _intensity, LightType _type, Point _position)
{
color = _color;
intensity = _intensity;
type = _type;
position = _position;
}
/// <summary>
/// Initializes a light, setting the light position. The
/// diffuse color is set to white; specular and ambient are left as black.
/// </summary>
/// <param name="light">Which light to initialize</param>
/// <param name="ltType">The type</param>
public static void InitLight(Light light, LightType ltType, float x, float y, float z)
{
light.Type = ltType;
light.Diffuse = System.Drawing.Color.White;
light.Position = new Vector3(x, y, z);
light.Direction = Vector3.Normalize(light.Position);
light.Range = 1000.0f;
}
public Light(LightType type, Color color, Vector3 pos, Vector3 dir, float att)
{
Type = type;
Color = color;
Position = pos;
Direction = dir;
Attenuation = att;
}
public LightClass(LightType Type, Vector3 Position, Color Ambiant, Color Diffuse, Color Specular, float Range)
{
this.Type = Type;
this.Position = Position;
this.Ambiant = Ambiant;
this.Diffuse = Diffuse;
this.Specular = Specular;
this.Range = Range;
}
public static void CreateApproachLight( int x, int y, int z, int off, int on, LightType light )
{
if ( FindMorphItem( x, y, z, off, on ) )
return;
MorphItem item = new MorphItem( off, on, 2, 3 );
item.Light = light;
item.MoveToWorld( new Point3D( x, y, z ), Map.Felucca );
m_Count++;
}
public static Light create(float x, float y, float size, float intensity, float r, float g, float b, float a, LightType type = LightType.VERTEX)
{
Light l = new Light();
l.set_colour(r, g, b, a);
l.attrib_size = size;
l.set_pos(x, y);
l.set_attribs(size, intensity);
l.set_type(type);
return l;
}
// Constructor
public Light(float _x, float _y, float _z, float _red, float _green, float _blue, float _intensity, float _radius,
LightType _type, string _name)
: base(_x, _y, _z, _name)
{
red = _red;
green = _green;
blue = _blue;
intensity = _intensity;
radius = _radius;
type = _type;
}
public LightVO(LightVO vo)
: base(vo)
{
type = vo.type;
rays = vo.rays;
distance = vo.distance;
directionDegree = vo.directionDegree;
coneDegree = vo.coneDegree;
isStatic = vo.isStatic;
isXRay = vo.isXRay;
softnessLength = vo.softnessLength;
}
static extern void LightSceneNode_GetLight(IntPtr light, [MarshalAs(UnmanagedType.LPArray)] float[] ambient,
[MarshalAs(UnmanagedType.LPArray)] float[] diffuse,
[MarshalAs(UnmanagedType.LPArray)] float[] specular,
[MarshalAs(UnmanagedType.LPArray)] float[] pos,
[MarshalAs(UnmanagedType.LPArray)] float[] dir,
[MarshalAs(UnmanagedType.LPArray)] float[] att,
ref float falloff,
ref float innercone,
ref float outercone,
ref float radius,
ref bool castshadows,
ref LightType type);
public Light(LightType lightType, Vector3 color, Vector3 position, bool castsShadows)
: base()
{
this.type = lightType;
this.Color = color;
this.Transformation.SetPosition(position);
this.castsShadows = castsShadows;
if (castsShadows)
{
CreateCascadeShadows(1024);
}
}
public int GetLight(LightType type, int x, int y, int z)
{
if (!IsValid(x, y, z))
return 0;
int chunkX = x >> 4;
int chunkY = z >> 4;
if (!IsChunkLoaded(chunkX, chunkY))
return 0;
var chunk = GetChunk(chunkX, chunkY);
return chunk.GetLight(type, x & 0xF, y, z & 0xF);
}
public Light(LightType aType)
{
fLightType = aType;
fConstant = 1.0f;
fLinear = 0.0f;
fQuadratic = 0.0f;
fIntensity = 1.0f;
// Setting up spotlight stuff
fAngle = (float)Math.PI;
fCosAngle = -1;
fSinAngle = 0.0f;
fExponent = 1.0f;
}
protected Light(LightType lightType)
{
LightType = lightType;
Texture2D LightTexture = LightTextureBuilder.CreatePointLight(Renderer.GD, 512);
KryptonLight = new Light2D()
{
Texture = LightTexture,
Range = (float)(1.5f),
Color = new Color(0.8f, 0.8f, 0.8f, 1f),
Intensity = 1f,
Angle = MathHelper.TwoPi * 0.5f,
X = (float)(0),
Y = (float)(0),
};
}
public LightType type; //read
#endregion Fields
#region Constructors
public LightData(ConfigNode node, Part part)
{
name = node.GetStringValue("name");
intensity = node.GetFloatValue("intensity");
range = node.GetFloatValue("range");
angle = node.GetFloatValue("angle");
type = (LightType)Enum.Parse(typeof(LightType), node.GetStringValue("type", LightType.Point.ToString()));
transform = part.transform.FindRecursive(name);
light = transform.GetComponent<Light>();
if (light == null)
{
light = transform.gameObject.AddComponent<Light>();//add it if it does not exist
}
light.intensity = intensity;
light.range = range;
light.spotAngle = angle;
light.type = type;
}
public LightSource(float[] RGB, Vector2 worldPos, LightType type, int range, GraphicsDevice graphicsDevice)
{
this.RGB = RGB;
this.worldPos = worldPos;
this.type = type;
this.range = range;
area = new RenderTarget2D(graphicsDevice, range*2, range*2);
output.Add(new RenderTarget2D(graphicsDevice, range * 2, range * 2));
output.Add(new RenderTarget2D(graphicsDevice, range * 2, range * 2));
int order = 2;
while(Math.Pow(2,order)<=range*2)
{
output.Add(new RenderTarget2D(graphicsDevice, (range * 2) / (int)Math.Pow(2, order), (range * 2)));
order++;
}
RenderArea.X = 0;
RenderArea.Y = 0;
RenderArea.Width = 2*range;
RenderArea.Height = 2*range;
}
LightSource FetchLight(LightType type, Color color, float intensity, float range, float spotAngle = 0.0f)
{
LightSource light = null;
if (activeHeadlights.Count == 0)
{
light = Singleton<RenderManager>.instance.ObtainLightSource();
}
else
{
light = activeHeadlights[0];
activeHeadlights.RemoveAt(0);
}
light.m_light.intensity = intensity*fadingHeadlightsFactor;
light.m_light.type = type;
light.m_light.color = color;
light.m_light.range = range;
light.m_light.spotAngle = spotAngle;
light.m_light.shadows = LightShadows.None;
light.enabled = true;
return light;
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="parent">Technique that owns this Pass.</param>
/// <param name="index">Index of this pass.</param>
public Pass( Technique parent, int index )
{
this._parent = parent;
this._index = index;
lock ( passLock )
{
this.passId = nextPassId++;
}
// color defaults
_ambient = ColorEx.White;
_diffuse = ColorEx.White;
_specular = ColorEx.Black;
_emissive = ColorEx.Black;
// by default, don't override the scene's fog settings
_fogOverride = false;
_fogMode = FogMode.None;
_fogColor = ColorEx.White;
_fogStart = 0;
_fogEnd = 1;
_fogDensity = 0.001f;
// default blending (overwrite)
_sourceBlendFactor = SceneBlendFactor.One;
_destinationBlendFactor = SceneBlendFactor.Zero;
// depth buffer settings
_depthCheck = true;
_depthWrite = true;
_colorWriteEnabled = true;
_depthFunction = CompareFunction.LessEqual;
// cull settings
_cullingMode = CullingMode.Clockwise;
_manualCullingMode = ManualCullingMode.Back;
// light settings
_lightingEnabled = true;
_runOnlyForOneLightType = true;
_onlyLightType = LightType.Point;
_shadingMode = Shading.Gouraud;
// Default max lights to the global max
_maxSimultaneousLights = Config.MaxSimultaneousLights;
_name = index.ToString();
IterationCount = 1;
DirtyHash();
}
/// <summary>
/// Method allowing to add a MenuItem to quickly build GameObjects with the component assigned
/// </summary>
/// <param name="menuCommand">Stuff that Unity automatically fills with some editor's contextual infos</param>
/// <param name="name">The name of the new GameObject</param>
/// <param name="type">The desired light's type</param>
/// <returns>The created AuraLight gameObject</returns>
private static GameObject CreateGameObject(MenuCommand menuCommand, string name, LightType type)
{
GameObject newGameObject = new GameObject(name);
GameObjectUtility.SetParentAndAlign(newGameObject, menuCommand.context as GameObject);
Undo.RegisterCreatedObjectUndo(newGameObject, "Create " + newGameObject.name);
Selection.activeObject = newGameObject;
newGameObject.AddComponent <Light>();
newGameObject.GetComponent <Light>().type = type;
newGameObject.GetComponent <Light>().shadows = LightShadows.Soft;
newGameObject.AddComponent <AuraLight>();
return(newGameObject);
}
/// <summary>
/// General purpose method to get any of the program sources.
/// </summary>
/// <param name="lightType">Type of light to get the source for.</param>
/// <param name="syntax">Syntax code of interest.</param>
/// <param name="finite">Is this for finite volume extrusion?</param>
/// <param name="debug">Should the shadow volumes be visible?</param>
/// <returns>Source of the specified program.</returns>
public static string GetProgramSource(LightType lightType, string syntax, bool finite, bool debug)
{
if (lightType == LightType.Directional)
{
if (syntax == "arbvp1")
{
if (finite)
{
if (debug)
{
return(dirArbvp1FiniteDebug);
}
else
{
return(dirArbvp1Finite);
}
}
else
{
if (debug)
{
return(dirArbvp1Debug);
}
else
{
return(dirArbvp1);
}
}
}
else
{
if (finite)
{
if (debug)
{
return(dirVs_1_1FiniteDebug);
}
else
{
return(dirVs_1_1Finite);
}
}
else
{
if (debug)
{
return(dirVs_1_1Debug);
}
else
{
return(dirVs_1_1);
}
}
}
}
else
{
if (syntax == "arbvp1")
{
if (finite)
{
if (debug)
{
return(pointArbvp1FiniteDebug);
}
else
{
return(pointArbvp1Finite);
}
}
else
{
if (debug)
{
return(pointArbvp1Debug);
}
else
{
return(pointArbvp1);
}
}
}
else
{
if (finite)
{
if (debug)
{
return(pointVs_1_1FiniteDebug);
}
else
{
return(pointVs_1_1Finite);
}
}
else
{
if (debug)
{
return(pointVs_1_1Debug);
}
else
{
return(pointVs_1_1);
}
}
}
}
}
public Light(LightType type, float intens, Vector3 pos = default(Vector3))
{
LightType = type;
Intensity = intens;
Position = pos;
}
/// <summary>
/// Initializes the component (command buffers, registrations, events, managed members ...)
/// </summary>
private void Initialize()
{
AuraCamera.OnRegisteredAuraCamerasListChanged += AuraCamera_OnRegistredAuraCamerasListChanged;
IsActive = AuraCamera.HasRegisteredAuraCameras;
if (!IsActive)
{
return;
}
InitializeResources();
_lightComponent = GetComponent <Light>();
_previousLightType = Type;
if (CastsShadows)
{
Vector2Int shadowMapSize = new Vector2Int(0, 0);
switch (Type)
{
case LightType.Directional:
{
shadowMapSize = DirectionalLightsManager.ShadowMapSize;
}
break;
case LightType.Spot:
{
shadowMapSize = SpotLightsManager.shadowMapSize;
}
break;
case LightType.Point:
{
shadowMapSize = PointLightsManager.shadowMapSize;
}
break;
}
shadowMapRenderTexture = new RenderTexture(shadowMapSize.x, shadowMapSize.y, 0, RenderTextureFormat.ARGBFloat, RenderTextureReadWrite.Linear);
shadowMapRenderTexture.name = gameObject.name + " : Shadow Map Render Texture";
shadowMapRenderTexture.Create();
RenderTargetIdentifier shadowMapRenderTextureIdentifier = BuiltinRenderTextureType.CurrentActive;
_copyShadowmapCommandBuffer = new CommandBuffer();
_copyShadowmapCommandBuffer.name = "Aura 2 : Store shadowmap";
_copyShadowmapCommandBuffer.SetShadowSamplingMode(shadowMapRenderTextureIdentifier, ShadowSamplingMode.RawDepth);
_copyShadowmapCommandBuffer.Blit(shadowMapRenderTextureIdentifier, new RenderTargetIdentifier(shadowMapRenderTexture));
LightComponent.AddCommandBuffer(LightEvent.AfterShadowMap, _copyShadowmapCommandBuffer);
switch (Type)
{
case LightType.Point:
{
_storePointLightShadowMapMaterial = new Material(_storePointLightShadowMapShader);
}
break;
case LightType.Directional:
{
if (shadowDataRenderTexture == null)
{
shadowDataRenderTexture = new RenderTexture(32, 1, 0, RenderTextureFormat.ARGBFloat, RenderTextureReadWrite.Linear);
shadowDataRenderTexture.name = gameObject.name + " : Shadow Data Render Texture";
}
_storeShadowDataCommandBuffer = new CommandBuffer();
_storeShadowDataCommandBuffer.name = "Aura 2 : Store directional shadow data";
_storeShadowDataMaterial = new Material(_storeDirectionalShadowDataShader);
LightComponent.AddCommandBuffer(LightEvent.BeforeScreenspaceMask, _storeShadowDataCommandBuffer);
_storeShadowDataCommandBuffer.Blit(null, new RenderTargetIdentifier(shadowDataRenderTexture), _storeShadowDataMaterial);
AuraCamera.CommonDataManager.LightsCommonDataManager.OnShadowsSettingsChanged += LightsCommonDataManager_OnCascadesCountChanged;
}
break;
}
}
_previousUseShadow = CastsShadows;
if (CastsCookie)
{
Vector2Int cookieMapSize = Vector2Int.zero;
switch (Type)
{
case LightType.Directional:
{
cookieMapSize = DirectionalLightsManager.cookieMapSize;
}
break;
case LightType.Spot:
{
cookieMapSize = SpotLightsManager.cookieMapSize;
}
break;
case LightType.Point:
{
cookieMapSize = PointLightsManager.cookieMapSize;
}
break;
}
cookieMapRenderTexture = new RenderTexture(cookieMapSize.x, cookieMapSize.y, 0, RenderTextureFormat.R8);
cookieMapRenderTexture.name = gameObject.name + " : Cookie Map Render Texture";
switch (Type)
{
case LightType.Point:
{
_storeCookieMapMaterial = new Material(_storePointLightCookieMapShader);
}
break;
default:
{
_storeCookieMapMaterial = new Material(_storeDirectionalSpotCookieMapShader);
}
break;
}
}
_previousUseCookie = CastsCookie;
AuraCamera.CommonDataManager.LightsCommonDataManager.RegisterLight(this);
Camera.onPreCull += Camera_onPreCull;
Camera.onPreRender += Camera_onPreRender;
_isInitialized = true;
}
private static extern void Internal_SetType(IntPtr instance, LightType value);
/// <summary>
/// Initializes the component (command buffers, registrations, events, managed members ...)
/// </summary>
private void Initialize()
{
_lightComponent = GetComponent <Light>();
_previousLightType = Type;
if (CastsShadows)
{
Vector2Int shadowMapSize = new Vector2Int(0, 0);
switch (Type)
{
case LightType.Directional:
{
shadowMapSize = DirectionalLightsManager.ShadowMapSize;
}
break;
case LightType.Spot:
{
shadowMapSize = SpotLightsManager.shadowMapSize;
}
break;
case LightType.Point:
{
shadowMapSize = PointLightsManager.shadowMapSize;
}
break;
}
shadowMapRenderTexture = new RenderTexture(shadowMapSize.x, shadowMapSize.y, 0, RenderTextureFormat.ARGBFloat, RenderTextureReadWrite.Linear);
shadowMapRenderTexture.Create();
RenderTargetIdentifier shadowMapRenderTextureIdentifier = BuiltinRenderTextureType.CurrentActive;
_copyShadowmapCommandBuffer = new CommandBuffer
{
name = "Aura : Copy light's shadowmap"
};
_copyShadowmapCommandBuffer.SetShadowSamplingMode(shadowMapRenderTextureIdentifier, ShadowSamplingMode.RawDepth);
_copyShadowmapCommandBuffer.Blit(shadowMapRenderTextureIdentifier, new RenderTargetIdentifier(shadowMapRenderTexture));
_lightComponent.AddCommandBuffer(LightEvent.AfterShadowMap, _copyShadowmapCommandBuffer);
switch (Type)
{
case LightType.Point:
{
_storePointLightShadowMapMaterial = new Material(storePointLightShadowMapShader);
}
break;
case LightType.Directional:
{
if (shadowDataRenderTexture == null)
{
shadowDataRenderTexture = new RenderTexture(32, 1, 0, RenderTextureFormat.ARGBFloat, RenderTextureReadWrite.Linear);
}
_storeShadowDataCommandBuffer = new CommandBuffer
{
name = "Aura : Store directional light's shadow data"
};
_storeShadowDataMaterial = new Material(storeShadowDataShader);
_lightComponent.AddCommandBuffer(LightEvent.BeforeScreenspaceMask, _storeShadowDataCommandBuffer);
_storeShadowDataCommandBuffer.Blit(null, new RenderTargetIdentifier(shadowDataRenderTexture), _storeShadowDataMaterial);
Aura.LightsManager.DirectionalLightsManager.OnCascadesCountChanged += DirectionalLightsManager_onCascadesCountChanged;
}
break;
}
}
_previousUseShadow = CastsShadows;
if (CastsCookie)
{
Vector2Int cookieMapSize = Vector2Int.zero;
switch (Type)
{
case LightType.Directional:
{
cookieMapSize = DirectionalLightsManager.cookieMapSize;
}
break;
case LightType.Spot:
{
cookieMapSize = SpotLightsManager.cookieMapSize;
}
break;
case LightType.Point:
{
cookieMapSize = PointLightsManager.cookieMapSize;
}
break;
}
cookieMapRenderTexture = new RenderTexture(cookieMapSize.x, cookieMapSize.y, 0, RenderTextureFormat.R8);
switch (Type)
{
case LightType.Point:
{
_storeCookieMapMaterial = new Material(storePointLightCookieMapShader);
}
break;
default:
{
_storeCookieMapMaterial = new Material(storeDirectionalSpotLightCookieMapShader);
}
break;
}
}
_previousUseCookie = CastsCookie;
Aura.LightsManager.Register(this, CastsShadows, CastsCookie);
if (_isRegistered)
{
Debug.Log("");//this is just here to remove not used error from console
}
_isRegistered = true;
Aura.OnPreCullEvent += Aura_onPreCullEvent;
Aura.OnPreRenderEvent += Aura_onPreRenderEvent;
_isInitialized = true;
}
public void set_type(LightType t)
{
type = t;
set_attribs(attrib_size, attrib_intensity);
set_pos(v_pos.x, v_pos.z);
}
public static List <Light> GetLights(LightType type, int layer)
{
return(null);
}
public LightClusterLinkedNode(LightType lightType, int lightIndex, int nextNode)
{
LightType = lightType;
LightIndex = lightIndex;
NextNode = nextNode;
}
private void AddLightToCluster(Dictionary <LightClusterLinkedNode, int> movedClusters, LightType lightType, int lightIndex, int clusterIndex)
{
var nextNode = -1;
if (lightNodes.Items[clusterIndex].LightIndex != -1)
{
var movedCluster = lightNodes.Items[clusterIndex];
// Try to check if same linked-list doesn't already exist
if (!movedClusters.TryGetValue(movedCluster, out nextNode))
{
// First time, let's add it
nextNode = lightNodes.Count;
movedClusters.Add(movedCluster, nextNode);
lightNodes.Add(movedCluster);
}
}
// Replace new linked-list head
lightNodes.Items[clusterIndex] = new LightClusterLinkedNode(lightType, lightIndex, nextNode);
}
private void LightType_SelectedIndexChanged(object sender, EventArgs e)
{
_lightType = (LightType)lstLightType.SelectedIndex;
_eventArgs.LightType = _lightType;
OnLightTypeChanged();
}
public void Setup(int exposureTime, int gain, LightType lightType)
{
this.tbrExposure.Value = MathUtils.Limit(exposureTime, this.tbrExposure.Minimum, this.tbrExposure.Maximum);
this.tbrGain.Value = MathUtils.Limit(gain, this.tbrGain.Minimum, this.tbrGain.Maximum);
this.cbxLight.SelectedItem = lightType;
}
internal void IncrementLightTypeCount( LightType lightType )
{
lightTypeCount[ (uint)lightType ]++;
}
public void UpdateLightType()
{
if (m_Light == null)
m_Light = GetComponent<Light>();
m_LightType = m_Light.type;
}
public static Light create(float x, float y, float size, float intensity, float r, float g, float b, float a, LightType type = LightType.VERTEX)
{
Light l = new Light();
l.set_colour(r, g, b, a);
l.attrib_size = size;
l.set_pos(x, y);
l.set_attribs(size, intensity);
l.set_type(type);
return(l);
}
public static extern Light[] GetLights(LightType type, int layer);
public UseLightModeRule(string name, LightType type, LightmapBakeType[] unusableBakeTypes) : base(name)
{
this.type = type;
this.unusableBakeTypes = unusableBakeTypes;
}
public LightEntry(LightType light, params int[] itemIDs)
{
m_Light = light;
m_ItemIDs = itemIDs;
}
private static int smethod_6(LightType lightType_0, LightType lightType_1)
{
return lightType_0.Name.CompareTo(lightType_1.Name);
}
public EmergencyLights(float distance, float angleDifference, LightType redLightType, LightType blueLightType, int timingIndex)
{
redLightLocalRotation = 0 - (angleDifference / 2);
blueLightLocalRotation = 0 + (angleDifference / 2);
redLightSpriteRotation = 0;
blueLightSpriteRotation = 0;
redLightLocalDistance = distance;
blueLightLocalDistance = distance;
this.redLight = GraphicsManager.GetLight(redLightType);
this.blueLight = GraphicsManager.GetLight(blueLightType);
this.timingIndex = timingIndex;
}
/// <summary>
/// Deserializes this PointLight.
/// </summary>
/// <param name="input">Input to read from</param>
public override void Read(Content.ISavableReader input)
{
base.Read(input);
_lightType = (LightType)input.ReadInt();
_position = input.ReadVector3();
}
/// <summary>
/// Initialize the creation of these core vertex programs.
/// </summary>
public static void Initialize()
{
// only need to initialize once
if (!isInitialized)
{
var syntax = "";
// flags for which of the programs use finite extrusion
var vertexProgramFinite = new bool[]
{
false, false, false, false, true, true, true, true
};
// flags for which of the programs use debug rendering
var vertexProgramDebug = new bool[]
{
false, true, false, true, false, true, false, true
};
// types of lights that each of the programs target
var vertexProgramLightTypes = new LightType[]
{
LightType.Point, LightType.Point, LightType.Directional, LightType.Directional,
LightType.Point, LightType.Point, LightType.Directional, LightType.Directional
};
// load hardware extrusion programs for point & dir lights
if (GpuProgramManager.Instance.IsSyntaxSupported("arbvp1"))
{
syntax = "arbvp1";
}
else if (GpuProgramManager.Instance.IsSyntaxSupported("vs_1_1"))
{
syntax = "vs_1_1";
}
else
{
throw new AxiomException(
"Vertex programs are supposedly supported, but neither arbvp1 nor vs_1_1 syntaxes are supported.");
}
// create the programs
for (var i = 0; i < programNames.Length; i++)
{
// sanity check to make sure it doesn't already exist
if (GpuProgramManager.Instance.GetByName(programNames[i]) == null)
{
var source = ShadowVolumeExtrudeProgram.GetProgramSource(vertexProgramLightTypes[i], syntax,
vertexProgramFinite[i], vertexProgramDebug[i]);
// create the program from the static source
var program = GpuProgramManager.Instance.CreateProgramFromString(programNames[i],
ResourceGroupManager.InternalResourceGroupName,
source, GpuProgramType.Vertex, syntax);
// load the program
program.Load();
}
}
isInitialized = true;
}
}
public Light(LightType type, IVector position, IRGBColor color)
{
this.Type = type;
this.Position = position;
this.Color = color;
}
public void SetType(LightType type)
{
Description.Type = ( int )type;
}
public Light(LightType type) : this(type, null, null)
{
}
/// <summary>
/// Method allowing to add a MenuItem to quickly build GameObjects with the component assigned
/// </summary>
/// <param name="name">The name of the new GameObject</param>
/// <param name="type">The desired light's type</param>
/// <returns>The created AuraLight gameObject</returns>
public static GameObject CreateGameObject(string name, LightType type)
{
return(CreateGameObject(new MenuCommand(null), name, type));
}
private static extern void Internal_setType(IntPtr thisPtr, LightType type);
/// <summary>
/// Sets whether or not this pass should be run once per light which
/// can affect the object being rendered.
/// </summary>
/// <remarks>
/// The default behavior for a pass (when this option is 'false'), is
/// for a pass to be rendered only once, with all the lights which could
/// affect this object set at the same time (up to the maximum lights
/// allowed in the render system, which is typically 8).
/// <p/>
/// Setting this option to 'true' changes this behavior, such that
/// instead of trying to issue render this pass once per object, it
/// is run once <b>per light</b> which can affect this object. In
/// this case, only light index 0 is ever used, and is a different light
/// every time the pass is issued, up to the total number of lights
/// which is affecting this object. This has 2 advantages:
/// <ul><li>There is no limit on the number of lights which can be
/// supported</li>
/// <li>It's easier to write vertex / fragment programs for this because
/// a single program can be used for any number of lights</li>
/// </ul>
/// However, this technique is a lot more expensive, and typically you
/// will want an additional ambient pass, because if no lights are
/// affecting the object it will not be rendered at all, which will look
/// odd even if ambient light is zero (imagine if there are lit objects
/// behind it - the objects silhouette would not show up). Therefore,
/// use this option with care, and you would be well advised to provide
/// a less expensive fallback technique for use in the distance.
/// <p/>
/// Note: The number of times this pass runs is still limited by the maximum
/// number of lights allowed as set in MaxLights, so
/// you will never get more passes than this.
/// </remarks>
/// <param name="enabled">Whether this feature is enabled.</param>
/// <param name="onlyForOneLightType">
/// If true, the pass will only be run for a single type of light, other light types will be ignored.
/// </param>
/// <param name="lightType">The single light type which will be considered for this pass.</param>
public void SetRunOncePerLight( bool enabled, bool onlyForOneLightType, LightType lightType )
{
_iteratePerLight = enabled;
_runOnlyForOneLightType = onlyForOneLightType;
_onlyLightType = lightType;
}
public static extern Light[] GetLights(LightType type, int layer);
/// <summary>
/// Normal constructor. Should not be called directly, but rather the SceneManager.CreateLight method should be used.
/// </summary>
/// <param name="name"></param>
public Light( string name )
: base( name )
{
// Default to point light, white diffuse light, linear attenuation, fair range
this.type = LightType.Point;
this.diffuse = ColorEx.White;
this.specular = ColorEx.Black;
this.range = 100000;
this.attenuationConst = 1.0f;
this.attenuationLinear = 0.0f;
this.attenuationQuad = 0.0f;
// Center in world, direction irrelevant but set anyway
this.position = Vector3.Zero;
this.direction = Vector3.UnitZ;
// Default some spot values
this.spotInner = 30.0f;
this.spotOuter = 40.0f;
this.spotFalloff = 1.0f;
this.localTransformDirty = false;
}
internal static extern void Light_SetLightType(IntPtr handle, LightType type);
public void UpdateLightType()
{
m_LightType = light.type;
}
/// <summary>
/// Set light type.
/// </summary>
private void SetLightType(LightType type)
{
Runtime.ValidateRefCounted(this);
Light_SetLightType(handle, type);
}
public override void Reset()
{
gameObject = null;
lightType = LightType.Point;
}
private static bool FindItem(int x, int y, int z, Map map, Item srcItem)
{
int itemID = srcItem.ItemID;
bool res = false;
IPooledEnumerable eable;
if (srcItem is BaseDoor)
{
eable = map.GetItemsInRange(new Point3D(x, y, z), 1);
foreach (Item item in eable)
{
if (!(item is BaseDoor))
{
continue;
}
BaseDoor bd = (BaseDoor)item;
Point3D p;
int bdItemID;
if (bd.Open)
{
p = new Point3D(bd.X - bd.Offset.X, bd.Y - bd.Offset.Y, bd.Z - bd.Offset.Z);
bdItemID = bd.ClosedID;
}
else
{
p = bd.Location;
bdItemID = bd.ItemID;
}
if (p.X != x || p.Y != y)
{
continue;
}
if (item.Z == z && bdItemID == itemID)
{
res = true;
}
else if (Math.Abs(item.Z - z) < 8)
{
m_DeleteQueue.Enqueue(item);
}
}
}
else if ((TileData.ItemTable[itemID & 0x3FFF].Flags & TileFlag.LightSource) != 0)
{
eable = map.GetItemsInRange(new Point3D(x, y, z), 0);
LightType lt = srcItem.Light;
string srcName = srcItem.ItemData.Name;
foreach (Item item in eable)
{
if (item.Z == z)
{
if (item.ItemID == itemID)
{
if (item.Light != lt)
{
m_DeleteQueue.Enqueue(item);
}
else
{
res = true;
}
}
else if ((item.ItemData.Flags & TileFlag.LightSource) != 0 && item.ItemData.Name == srcName)
{
m_DeleteQueue.Enqueue(item);
}
}
}
}
else if (srcItem is Teleporter || srcItem is FillableContainer || srcItem is BaseBook)
{
eable = map.GetItemsInRange(new Point3D(x, y, z), 0);
Type type = srcItem.GetType();
foreach (Item item in eable)
{
if (item.Z == z && item.ItemID == itemID)
{
if (item.GetType() != type)
{
m_DeleteQueue.Enqueue(item);
}
else
{
res = true;
}
}
}
}
else
{
eable = map.GetItemsInRange(new Point3D(x, y, z), 0);
foreach (Item item in eable)
{
if (item.Z == z && item.ItemID == itemID)
{
eable.Free();
return(true);
}
}
}
eable.Free();
while (m_DeleteQueue.Count > 0)
{
((Item)m_DeleteQueue.Dequeue()).Delete();
}
return(res);
}
private bool IsSupportedShadowType(LightType type)
{
return(type == LightType.Directional || type == LightType.Spot);
}
public static void LoadMap(string MapName = "")
{
try
{
XmlDocument XML = new XmlDocument();
XmlNode xmlNode;
XmlNodeList xmlNodeList;
XML.Load(MapsList[MapName]);
Maps.Name = XML.DocumentElement.SelectSingleNode("Name").InnerText;
Log.WriteLine("Loading map: \"{0}\"", MapName);
if (XML.DocumentElement.SelectNodes("Description").Count > 0)
{
Maps.Description = XML.DocumentElement.SelectSingleNode("Description").InnerText;
}
#region PlayerStart
if (XML.DocumentElement.SelectNodes("PlayerStart").Count > 0)
{
xmlNode = XML.DocumentElement.SelectSingleNode("PlayerStart");
if (xmlNode.SelectNodes("Position").Count > 0)
{
string[] Position = xmlNode.SelectSingleNode("Position").InnerText.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
Game.MainCamera.Position = new Vector3(float.Parse(Position[0]), float.Parse(Position[1]), float.Parse(Position[2]));
PlayerStartPos = Game.MainCamera.Position;
}
if (xmlNode.SelectNodes("Rotation").Count > 0)
{
string[] Rotation = xmlNode.SelectSingleNode("Rotation").InnerText.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
float Yaw = float.Parse(Rotation[0]);
float Pitch = float.Parse(Rotation[1]);
Game.MainCamera.YawPitch = new Vector2(
MathHelper.DegreesToRadians(-Yaw),
MathHelper.DegreesToRadians(Pitch));
PlayerStartRot = new Vector2(Yaw, Pitch);
}
}
#endregion
#region Camera
if (XML.DocumentElement.SelectNodes("Camera").Count > 0)
{
xmlNode = XML.DocumentElement.SelectSingleNode("Camera");
if (xmlNode.SelectNodes("Near").Count > 0)
{
Game.MainCamera.zNear = float.Parse(xmlNode.SelectSingleNode("Near").InnerText);
}
if (xmlNode.SelectNodes("Far").Count > 0)
{
Game.MainCamera.zFar = float.Parse(xmlNode.SelectSingleNode("Far").InnerText);
}
if (xmlNode.SelectNodes("FOV").Count > 0)
{
Game.MainCamera.FOV = float.Parse(xmlNode.SelectSingleNode("FOV").InnerText);
}
if (xmlNode.SelectNodes("MoveSpeed").Count > 0)
{
Game.MainCamera.MoveSpeed = float.Parse(xmlNode.SelectSingleNode("MoveSpeed").InnerText);
}
}
#endregion
#region SkyBox
if (XML.DocumentElement.SelectNodes("Skybox").Count > 0)
{
string SkyBox = XML.DocumentElement.SelectSingleNode("Skybox").InnerText;
if (SkyBox != null && SkyBox != String.Empty)
{
Game.SkyBox = new Mesh();
MeshPart MPart = MeshPart.MakeBox(Game.MainCamera.zFar * 2.0f / (float)Math.Sqrt(3.0), true); // Cube diagonal = side / sqrt(3)
MPart.Material = Materials.Load(SkyBox);
Game.SkyBox.Parts.Add(MPart);
Game.SkyBox.CalcBoundingObjects();
}
}
#endregion
#region Fog
if (XML.DocumentElement.SelectNodes("Fog").Count > 0)
{
xmlNode = XML.DocumentElement.SelectSingleNode("Fog");
if (xmlNode.SelectNodes("Enabled").Count > 0)
{
Settings.Graphics.Fog.UseFogOnMap = Convert.ToBoolean(xmlNode.SelectSingleNode("Enabled").InnerText);
}
if (xmlNode.SelectNodes("Color").Count > 0)
{
try
{
string[] Color = xmlNode.SelectSingleNode("Color").InnerText.Split(
new char[] { ' ', ';' }, StringSplitOptions.RemoveEmptyEntries);
float R, G, B;
switch (Color.Length)
{
case 1:
R = float.Parse(Color[0]);
Settings.Graphics.Fog.Color = new Vector3(R, R, R);
break;
case 3:
R = float.Parse(Color[0]);
G = float.Parse(Color[1]);
B = float.Parse(Color[2]);
Settings.Graphics.Fog.Color = new Vector3(R, G, B);
break;
default:
break;
}
}
catch { }
}
if (xmlNode.SelectNodes("DistanceMin").Count > 0)
{
Settings.Graphics.Fog.MinDistance = float.Parse(xmlNode.SelectSingleNode("DistanceMin").InnerText);
}
if (xmlNode.SelectNodes("DistanceMax").Count > 0)
{
Settings.Graphics.Fog.MaxDistance = float.Parse(xmlNode.SelectSingleNode("DistanceMax").InnerText);
}
}
#endregion
#region Models
foreach (XmlNode xmlNodeModel in XML.DocumentElement.SelectNodes("Model"))
{
Model model = new Model();
model.Name = xmlNodeModel.SelectSingleNode("Name").InnerText;
if (xmlNodeModel.SelectNodes("Visible").Count > 0)
{
model.Visible = Convert.ToBoolean(xmlNodeModel.SelectSingleNode("Visible").InnerText);
}
foreach (XmlNode xmlNodeMesh in xmlNodeModel.SelectNodes("Mesh"))
{
Mesh mesh = new Mesh();
string Name = xmlNodeMesh.SelectSingleNode("Name").InnerText;
MeshType meshType = MeshType.Mesh;
if (xmlNodeMesh.SelectNodes("Type").Count > 0)
{
string meshTypeStr = xmlNodeMesh.SelectSingleNode("Type").InnerText;
try
{
meshType = (MeshType)Enum.Parse(typeof(MeshType), meshTypeStr, true);
}
catch
{
meshType = MeshType.Mesh;
}
}
float SideA, SideB, SideC;
MeshPart mp;
bool FlipPolygons = false;
switch (meshType)
{
case MeshType.Plain:
mesh.Name = Name;
mesh.MeshName = meshType.ToString();
SideA = float.Parse(xmlNodeMesh.SelectSingleNode("SideA").InnerText);
SideB = float.Parse(xmlNodeMesh.SelectSingleNode("SideB").InnerText);
mp = MeshPart.MakePlain(SideA, SideB);
mesh.Parts.Add(mp);
mesh.CalcBoundingObjects();
break;
case MeshType.Box:
mesh.Name = Name;
mesh.MeshName = meshType.ToString();
SideA = float.Parse(xmlNodeMesh.SelectSingleNode("SideA").InnerText);
SideB = float.Parse(xmlNodeMesh.SelectSingleNode("SideB").InnerText);
SideC = float.Parse(xmlNodeMesh.SelectSingleNode("SideC").InnerText);
if (xmlNodeMesh.SelectNodes("FlipPolygons").Count > 0)
{
FlipPolygons = Convert.ToBoolean(xmlNodeMesh.SelectSingleNode("FlipPolygons").InnerText);
}
mp = MeshPart.MakeBox(SideA, SideB, SideC, FlipPolygons);
mesh.Parts.Add(mp);
mesh.CalcBoundingObjects();
break;
case MeshType.Mesh:
default:
string MeshName = xmlNodeMesh.SelectSingleNode("Mesh").InnerText;
mesh = Meshes.Load(Name, MeshName);
break;
}
string[] Pos = xmlNodeMesh.SelectSingleNode("Position").InnerText.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
mesh.Position = new Vector3(float.Parse(Pos[0]), float.Parse(Pos[1]), float.Parse(Pos[2]));
string[] Rot = xmlNodeMesh.SelectSingleNode("Rotation").InnerText.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
mesh.Rotation = new Vector3(MathHelper.DegreesToRadians(float.Parse(Rot[0])),
MathHelper.DegreesToRadians(float.Parse(Rot[1])), MathHelper.DegreesToRadians(float.Parse(Rot[2])));
string[] Scl = xmlNodeMesh.SelectSingleNode("Scale").InnerText.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
mesh.Scale = new Vector3(float.Parse(Scl[0]), float.Parse(Scl[1]), float.Parse(Scl[2]));
XmlNodeList xmlMaterials = xmlNodeMesh.SelectSingleNode("Materials").SelectNodes("Material");
int Count = Math.Min(xmlMaterials.Count, mesh.Parts.Count);
for (int i = 0; i < Count; i++)
{
mesh.Parts[i].Material = Materials.Load(xmlMaterials[i].InnerText);
}
if (Count < mesh.Parts.Count && Count > 0)
{
for (int i = Count; i < mesh.Parts.Count; i++)
{
mesh.Parts[i].Material = mesh.Parts[0].Material;
}
}
model.Meshes.Add(mesh);
}
Models.MODELS.Add(model);
}
#endregion
#region Light
foreach (XmlNode xmlNodeLight in XML.DocumentElement.SelectNodes("Light"))
{
Light light = new Light();
light.Name = xmlNodeLight.SelectSingleNode("Name").InnerText;
if (xmlNodeLight.SelectNodes("Enabled").Count > 0)
{
light.Enabled = Convert.ToBoolean(xmlNodeLight.SelectSingleNode("Enabled").InnerText);
}
LightType lightType = LightType.Point;
if (xmlNodeLight.SelectNodes("Type").Count > 0)
{
string meshTypeStr = xmlNodeLight.SelectSingleNode("Type").InnerText;
try
{
lightType = (LightType)Enum.Parse(typeof(LightType), meshTypeStr, true);
}
catch
{
lightType = LightType.Point;
}
light.Type = lightType;
}
#region Diffuse Light
xmlNodeList = xmlNodeLight.SelectNodes("Diffuse");
if (xmlNodeList.Count > 0)
{
try
{
string[] Diffuse = xmlNodeList.Item(0).InnerText.Split(
new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
float R, G, B;
switch (Diffuse.Length)
{
case 1:
R = float.Parse(Diffuse[0]);
light.Diffuse = new Vector3(R, R, R);
break;
case 3:
R = float.Parse(Diffuse[0]);
G = float.Parse(Diffuse[1]);
B = float.Parse(Diffuse[2]);
light.Diffuse = new Vector3(R, G, B);
break;
}
}
catch { }
}
#endregion
#region Specular Light
xmlNodeList = xmlNodeLight.SelectNodes("Specular");
if (xmlNodeList.Count > 0)
{
string[] Specular = xmlNodeList.Item(0).InnerText.Split(
new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
float R, G, B;
switch (Specular.Length)
{
case 1:
R = float.Parse(Specular[0]);
light.Specular = new Vector3(R, R, R);
break;
case 3:
R = float.Parse(Specular[0]);
G = float.Parse(Specular[1]);
B = float.Parse(Specular[2]);
light.Specular = new Vector3(R, G, B);
break;
}
}
#endregion
#region Position
xmlNodeList = xmlNodeLight.SelectNodes("Position");
if (xmlNodeList.Count > 0)
{
string[] Pos = xmlNodeList.Item(0).InnerText.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
light.Position = new Vector3(float.Parse(Pos[0]), float.Parse(Pos[1]), float.Parse(Pos[2]));
}
#endregion
#region Direction
xmlNodeList = xmlNodeLight.SelectNodes("Direction");
if (xmlNodeList.Count > 0)
{
string[] Direct = xmlNodeList.Item(0).InnerText.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
light.Direction = Vector3.FromYawPitch(
MathHelper.DegreesToRadians(float.Parse(Direct[0])),
MathHelper.DegreesToRadians(float.Parse(Direct[1])));
}
#endregion
#region Attenuation
xmlNodeList = xmlNodeLight.SelectNodes("Attenuation");
if (xmlNodeList.Count > 0)
{
string[] Atten = xmlNodeList.Item(0).InnerText.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
light.Attenuation = new Vector3(float.Parse(Atten[0]), float.Parse(Atten[1]), float.Parse(Atten[2]));
}
#endregion
if (xmlNodeLight.SelectNodes("CutOFF").Count > 0)
{
light.CutOFF = float.Parse(xmlNodeLight.SelectSingleNode("CutOFF").InnerText);
}
if (xmlNodeLight.SelectNodes("Exponent").Count > 0)
{
light.Exponent = float.Parse(xmlNodeLight.SelectSingleNode("Exponent").InnerText);
}
Lights.LIGHTS.Add(light);
}
#endregion
#region Sounds
//xmlNodeList = XML.DocumentElement.SelectSingleNode("Sounds").SelectNodes("Sound");
//foreach (XmlNode xmlNodeSound in xmlNodeList)
//{
// string SndName = xmlNodeSound.SelectSingleNode("Name").InnerText;
// bool SndEnabled = Convert.ToBoolean(xmlNodeSound.SelectSingleNode("Enabled").InnerText);
// string SndFile = xmlNodeSound.SelectSingleNode("File").InnerText;
// int SndVolume = Convert.ToInt32(xmlNodeSound.SelectSingleNode("Volume").InnerText);
// int SndRadius = Convert.ToInt32(xmlNodeSound.SelectSingleNode("Radius").InnerText);
// string[] SndPos = xmlNodeSound.SelectSingleNode("Position").InnerText.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
// Vector3 SndPosition = new Vector3(
// float.Parse(SndPos[0]),
// float.Parse(SndPos[1]),
// float.Parse(SndPos[2]));
//}
#endregion
Log.WriteLineGreen("Done.");
}
catch
{
Log.WriteLineRed("Map \"{0}\" loading Error!\n\t", MapName);
}
}
public LightWrapper(IEnumerable results, BfCache cache)
{
if (results == null)
{
Console.WriteLine("no results");
}
else
{
object obj = results.OfType<object>().FirstOrDefault<object>();
if (obj == null)
{
Console.WriteLine("results are empty");
}
else
{
IEnumerable<PropertyInfo> arg_A8_0 = obj.GetType().GetProperties();
if (LightWrapper.func_0 == null)
{
LightWrapper.func_0 = new Func<PropertyInfo, bool>(LightWrapper.smethod_0);
}
PropertyInfo propertyInfo = arg_A8_0.FirstOrDefault(LightWrapper.func_0);
if (propertyInfo != null)
{
Dictionary<int, object> idToLeaf = new Dictionary<int, object>();
foreach (object current in results)
{
int key = (int)propertyInfo.GetGetMethod().Invoke(current, null);
if (!idToLeaf.ContainsKey(key))
{
idToLeaf.Add(key, current);
}
}
if (string.Compare(propertyInfo.Name, "MethodId", true) == 0)
{
var enumerable = from method in cache.Methods
where idToLeaf.ContainsKey(method.MethodId)
select new
{
Type = method.Type,
Assembly = method.Type.Assembly,
Namespace = method.Type.Namespace,
Leaf = idToLeaf[method.MethodId]
};
string childType = "Method";
foreach (var current2 in enumerable)
{
LightAssembly lightAssembly = new LightAssembly(current2.Assembly, childType);
lightAssembly = this.Assemblies.method_2(lightAssembly);
LightNamespace lightNamespace = new LightNamespace(current2.Namespace, childType);
lightNamespace = lightAssembly.Namespaces.method_2(lightNamespace);
LightNamespace lightNamespace2 = new LightNamespace(current2.Namespace, childType);
lightNamespace2 = this.Namespaces.method_2(lightNamespace2);
LightType lightType = new LightType(current2.Type, childType);
lightType = this.Types.method_2(lightType);
lightNamespace.Types.method_2(lightType);
lightNamespace2.Types.method_2(lightType);
lightType.Children.method_2(current2.Leaf);
this.TypesChildren.method_2(current2.Leaf);
}
}
if (string.Compare(propertyInfo.Name, "FieldId", true) == 0)
{
var enumerable = from field in cache.Fields
where idToLeaf.ContainsKey(field.FieldId)
select new
{
Type = field.Type,
Assembly = field.Type.Assembly,
Namespace = field.Type.Namespace,
Leaf = idToLeaf[field.FieldId]
};
string childType = "Field";
foreach (var current2 in enumerable)
{
LightAssembly lightAssembly = new LightAssembly(current2.Assembly, childType);
lightAssembly = this.Assemblies.method_2(lightAssembly);
LightNamespace lightNamespace = new LightNamespace(current2.Namespace, childType);
lightNamespace = lightAssembly.Namespaces.method_2(lightNamespace);
LightNamespace lightNamespace2 = new LightNamespace(current2.Namespace, childType);
lightNamespace2 = this.Namespaces.method_2(lightNamespace2);
LightType lightType = new LightType(current2.Type, childType);
lightType = this.Types.method_2(lightType);
lightNamespace.Types.method_2(lightType);
lightNamespace2.Types.method_2(lightType);
lightType.Children.method_2(current2.Leaf);
this.TypesChildren.method_2(current2.Leaf);
}
}
if (string.Compare(propertyInfo.Name, "EventId", true) == 0)
{
var enumerable = from ev in cache.Events
where idToLeaf.ContainsKey(ev.EventId)
select new
{
Type = ev.Type,
Assembly = ev.Type.Assembly,
Namespace = ev.Type.Namespace,
Leaf = idToLeaf[ev.EventId]
};
string childType = "Event";
foreach (var current2 in enumerable)
{
LightAssembly lightAssembly = new LightAssembly(current2.Assembly, childType);
lightAssembly = this.Assemblies.method_2(lightAssembly);
LightNamespace lightNamespace = new LightNamespace(current2.Namespace, childType);
lightNamespace = lightAssembly.Namespaces.method_2(lightNamespace);
LightNamespace lightNamespace2 = new LightNamespace(current2.Namespace, childType);
lightNamespace2 = this.Namespaces.method_2(lightNamespace2);
LightType lightType = new LightType(current2.Type, childType);
lightType = this.Types.method_2(lightType);
lightNamespace.Types.method_2(lightType);
lightNamespace2.Types.method_2(lightType);
lightType.Children.method_2(current2.Leaf);
this.TypesChildren.method_2(current2.Leaf);
}
}
if (string.Compare(propertyInfo.Name, "TypeId", true) == 0)
{
var enumerable2 = from type in cache.Types
where idToLeaf.ContainsKey(type.TypeId)
select new
{
type = type,
Assembly = type.Assembly,
Namespace = type.Namespace,
Leaf = idToLeaf[type.TypeId]
};
string childType = "Type";
foreach (var current3 in enumerable2)
{
LightAssembly lightAssembly = new LightAssembly(current3.Assembly, childType);
lightAssembly = this.Assemblies.method_2(lightAssembly);
LightNamespace lightNamespace = new LightNamespace(current3.Namespace, childType);
lightNamespace = lightAssembly.Namespaces.method_2(lightNamespace);
LightNamespace lightNamespace2 = new LightNamespace(current3.Namespace, childType);
lightNamespace2 = this.Namespaces.method_2(lightNamespace2);
LightType lightType = new LightType(current3.type, childType);
lightType = this.Types.method_2(lightType);
lightNamespace.Types.method_2(lightType);
lightNamespace2.Types.method_2(lightType);
lightNamespace.Children.method_2(current3.Leaf);
lightNamespace2.Children.method_2(current3.Leaf);
this.TypesChildren.method_2(current3.Leaf);
}
}
if (string.Compare(propertyInfo.Name, "NamespaceId", true) == 0)
{
var enumerable3 = from nspace in cache.Namespaces
where idToLeaf.ContainsKey(nspace.NamespaceId)
select new
{
nspace = nspace,
Leaf = idToLeaf[nspace.NamespaceId]
};
string childType = "GeneralNamespace";
foreach (var current4 in enumerable3)
{
LightNamespace lightNamespace2 = new LightNamespace(current4.nspace, childType);
lightNamespace2 = this.Namespaces.method_2(lightNamespace2);
lightNamespace2.Children.method_2(current4.Leaf);
}
}
if (string.Compare(propertyInfo.Name, "AssemblyId", true) == 0)
{
var enumerable4 = from assembly in cache.Assemblies
where idToLeaf.ContainsKey(assembly.AssemblyId)
select new
{
assembly = assembly,
Leaf = idToLeaf[assembly.AssemblyId]
};
string childType = "Assembly";
foreach (var current5 in enumerable4)
{
LightAssembly lightAssembly2 = new LightAssembly(current5.assembly, childType);
this.Assemblies.method_2(lightAssembly2);
lightAssembly2.Children.method_2(current5.Leaf);
}
}
}
LightCollection<LightAssembly> arg_863_0 = this.lightCollection_0;
if (LightWrapper.comparison_0 == null)
{
LightWrapper.comparison_0 = new Comparison<LightAssembly>(LightWrapper.smethod_1);
}
arg_863_0.method_1(LightWrapper.comparison_0);
foreach (LightAssembly lightAssembly in ((IEnumerable<LightAssembly>)this.lightCollection_0))
{
LightAssembly lightAssembly;
LightCollection<LightNamespace> arg_8A8_0 = lightAssembly.Namespaces;
if (LightWrapper.comparison_1 == null)
{
LightWrapper.comparison_1 = new Comparison<LightNamespace>(LightWrapper.smethod_2);
}
arg_8A8_0.method_1(LightWrapper.comparison_1);
foreach (LightNamespace current6 in ((IEnumerable<LightNamespace>)lightAssembly.Namespaces))
{
LightCollection<LightType> arg_8EB_0 = current6.Types;
if (LightWrapper.comparison_2 == null)
{
LightWrapper.comparison_2 = new Comparison<LightType>(LightWrapper.smethod_3);
}
arg_8EB_0.method_1(LightWrapper.comparison_2);
}
}
LightCollection<LightNamespace> arg_94A_0 = this.lightCollection_1;
if (LightWrapper.comparison_3 == null)
{
LightWrapper.comparison_3 = new Comparison<LightNamespace>(LightWrapper.smethod_4);
}
arg_94A_0.method_1(LightWrapper.comparison_3);
foreach (LightNamespace current6 in ((IEnumerable<LightNamespace>)this.lightCollection_1))
{
LightCollection<LightType> arg_98C_0 = current6.Types;
if (LightWrapper.comparison_4 == null)
{
LightWrapper.comparison_4 = new Comparison<LightType>(LightWrapper.smethod_5);
}
arg_98C_0.method_1(LightWrapper.comparison_4);
}
LightCollection<LightType> arg_9CE_0 = this.lightCollection_2;
if (LightWrapper.comparison_5 == null)
{
LightWrapper.comparison_5 = new Comparison<LightType>(LightWrapper.smethod_6);
}
arg_9CE_0.method_1(LightWrapper.comparison_5);
}
}
}
public static bool IsSupportedCookieType(LightType lightType)
{
return(lightType == LightType.Directional || lightType == LightType.Spot);
}
