public async Task Setup()
{
string ip = await GetBridgeIp();
hueClient = new LocalHueClient(ip, Secrets.HueUsername);
var lights = await hueClient.GetLightsAsync();
foreach (var light in lights)
{
lightToId.Add(light.Name, light.Id);
Lights.Add(light.Name);
}
var groups = await hueClient.GetGroupsAsync();
foreach (var group in groups)
{
var name = group.Name;
if (name.Contains("Group for"))
{
continue;
}
if (Lights.Contains(name))
{
name = $"{name} (group)";
}
groupToId.Add(name, group.Id);
Lights.Add(name);
}
}
// Sorts scene node into correct list.
protected void AddNode(SceneNode node)
{
if (node is DecalNode)
{
DecalNodes.Add(node);
}
else if (node is LightNode)
{
Lights.Add(node);
}
else if (node is LensFlareNode)
{
LensFlareNodes.Add(node);
}
else if (node is SkyNode)
{
SkyNodes.Add(node);
}
else if (node is FogNode)
{
FogNodes.Add(node);
}
else if (node.IsRenderable)
{
RenderableNodes.Add(node);
}
// Unsupported types are simply ignored.
}
protected override void ReadData(DataBuffer buf, FileFormat fmt)
{
WheelDamageEffect = buf.ReadFloat();
Engine = buf.ReadByte();
Wheels = buf.ReadArray <WheelStatus>(NumWheels);
Doors = buf.ReadArray <DoorStatus>(NumDoors);
buf.Skip(1);
int lightStatus = buf.ReadInt32();
int panelStatus = buf.ReadInt32();
Field24h = buf.ReadInt32();
Lights.Clear();
for (int i = 0; i < NumLights; i++)
{
Lights.Add((LightStatus)(lightStatus & 0x3));
lightStatus >>= 2;
}
Panels.Clear();
for (int i = 0; i < NumPanels; i++)
{
Panels.Add((PanelStatus)(panelStatus & 0xF));
panelStatus >>= 4;
}
Debug.Assert(buf.Offset == SizeOfType <DamageManager>());
}
public void Read(System.IO.BinaryReader r)
{
TileWidth = r.ReadInt32();
TileHeight = r.ReadInt32();
int lc = r.ReadInt32();
for (int i = 0; i < lc; i++)
{
var l = new Vivid.Scene.GraphLight();
l.Read(r);
Lights.Add(l);
}
int mc = r.ReadInt32();
for (int i = 0; i < mc; i++)
{
var m = new Vivid.Scene.GraphMarker();
m.Read(r);
Markers.Add(m);
}
int layc = r.ReadInt32();
Layers = new List <MapLayer>();
for (int l = 0; l < layc; l++)
{
var ml = new MapLayer(1, 1, this);
ml.Read(r);
Layers.Add(ml);
}
}
private void CalculateLighting()
{
//Setup lights for NEE
this.Lights = new List <Shape>();
foreach (Shape S in Shapes)
{
if (S.Material.HasProperty("emission") && !(S is Plane)) //Infinite planes not included
{
Lights.Add(S);
}
}
//Setup light probabiltiies
this.LightProbabilityTable = new double[Lights.Count];
double TotalLightWeight = 0;
for (int i = 0; i < Lights.Count; i++)
{
double LightWeight = Lights[i].Material.GetProperty("emission", Vector2.Zero).Color.SumComponents() * Lights[i].Area();
TotalLightWeight += LightWeight;
LightProbabilityTable[i] = TotalLightWeight;
}
for (int i = 0; i < Lights.Count; i++)
{
LightProbabilityTable[i] /= TotalLightWeight;
}
}
//method to fill the scene
public void FillScene()
{
//add lights to the scene
Light light1 = new Light(new Vector3(-2, -2, 1), new Vector3(1, 0, 0), 10);
Light light2 = new Light(new Vector3(2, -2, 7), new Vector3(0, 1, 0), 10);
Light bigLight = new Light(new Vector3(0, -3, 2), new Vector3(1, 1, 1), 25);
Lights.Add(bigLight);
Lights.Add(light1);
Lights.Add(light2);
//add primitives to the scene
Floor = new Plane("Floor", new Vector3(0, 1, 0), -1, new Vector3(50, 50, 50), "Specular"); //gray floor plane
Sphere1 = new Sphere("Sphere1", new Vector3(-2, 0, 4), 1, new Vector3(255, 0, 0), "Specular"); //left sphere
Sphere2 = new Sphere("Sphere2", new Vector3(0, 0, 5), 1, new Vector3(255, 255, 255), "Mirror"); //middle sphere
Sphere3 = new Sphere("Sphere3", new Vector3(3, 0, 5), 1, new Vector3(0, 0, 255), "Specular"); //right sphere
Triangle Triangle1 = new Triangle("Triangle1", new Vector3(0, 1, 3), new Vector3(1, -2, 4), new Vector3(2, 1, 3), new Vector3(0, 0, 255), "Diffuse");
sceneObjects.Add(Floor); //add the primitives
sceneObjects.Add(Sphere1);
sceneObjects.Add(Sphere2);
sceneObjects.Add(Sphere3);
sceneObjects.Add(Triangle1);
}
/// <summary>
/// Adds a new light.
/// </summary>
/// <returns>New light.</returns>
public Light NewLight()
{
Light tmp = new Light();
Lights.Add(tmp);
return(tmp);
}
public virtual void ReadChildData(BinaryReader reader)
{
int x = 0;
_model.ReadString(reader);
_animationgraph.ReadString(reader);
_indoorFogScreen.ReadString(reader);
for (x = 0; (x < _shaderFunctions.Count); x = (x + 1))
{
ShaderFunctions.Add(new SkyShaderFunctionBlock());
ShaderFunctions[x].Read(reader);
}
for (x = 0; (x < _shaderFunctions.Count); x = (x + 1))
{
ShaderFunctions[x].ReadChildData(reader);
}
for (x = 0; (x < _animations.Count); x = (x + 1))
{
Animations.Add(new SkyAnimationBlock());
Animations[x].Read(reader);
}
for (x = 0; (x < _animations.Count); x = (x + 1))
{
Animations[x].ReadChildData(reader);
}
for (x = 0; (x < _lights.Count); x = (x + 1))
{
Lights.Add(new SkyLightBlock());
Lights[x].Read(reader);
}
for (x = 0; (x < _lights.Count); x = (x + 1))
{
Lights[x].ReadChildData(reader);
}
}
/// <summary>
/// Adds a region to the appropriate list for its type; returns the region.
/// </summary>
public Region Add(Region region)
{
switch (region)
{
case Region.Region0 r: Region0s.Add(r); break;
case Region.Light r: Lights.Add(r); break;
case Region.StartPoint r: StartPoints.Add(r); break;
case Region.Sound r: Sounds.Add(r); break;
case Region.SFX r: SFXs.Add(r); break;
case Region.Wind r: Winds.Add(r); break;
case Region.EnvLight r: EnvLights.Add(r); break;
case Region.Fog r: Fogs.Add(r); break;
default:
throw new ArgumentException($"Unrecognized type {region.GetType()}.", nameof(region));
}
return(region);
}
/// <summary>
/// Adds an event to the appropriate list for its type; returns the event.
/// </summary>
public Event Add(Event evnt)
{
switch (evnt)
{
case Event.Light e: Lights.Add(e); break;
case Event.Sound e: Sounds.Add(e); break;
case Event.SFX e: SFX.Add(e); break;
case Event.Wind e: Wind.Add(e); break;
case Event.Treasure e: Treasures.Add(e); break;
case Event.Generator e: Generators.Add(e); break;
case Event.Message e: Messages.Add(e); break;
case Event.ObjAct e: ObjActs.Add(e); break;
case Event.SpawnPoint e: SpawnPoints.Add(e); break;
case Event.MapOffset e: MapOffsets.Add(e); break;
case Event.Navmesh e: Navmeshes.Add(e); break;
case Event.Environment e: Environments.Add(e); break;
case Event.PseudoMultiplayer e: PseudoMultiplayers.Add(e); break;
default:
throw new ArgumentException($"Unrecognized type {evnt.GetType()}.", nameof(evnt));
}
return(evnt);
}
public FirstScene()
{
Shape floor = new Sphere();
floor.Transform = Transformation.Scaling(10, 0.01f, 10);
floor.Material.Color = Tuple.Color(1, 0.9f, 0.9f);
floor.Material.Specular = 0;
Shapes.Add(floor);
Shape leftWall = new Sphere();
leftWall.Transform = Transformation.Translation(0, 0, 5) *
Transformation.RotationY(-PI / 4) * Transformation.RotationX(PI / 2) *
Transformation.Scaling(10, 0.2f, 10);
leftWall.Material = floor.Material;
Shapes.Add(leftWall);
Shape rightWall = new Sphere();
rightWall.Transform = Transformation.Translation(0, 0, 5) *
Transformation.RotationY(PI / 4) * Transformation.RotationX(PI / 2) *
Transformation.Scaling(10, 0.2f, 10);
rightWall.Material = floor.Material;
Shapes.Add(rightWall);
Shape middle = new Sphere();
middle.Transform = Transformation.Translation(-0.5f, 1, 0.5f);
middle.Material.Color = Tuple.Color(0.1f, 1, 0.5f);
middle.Material.Diffuse = 0.7f;
middle.Material.Specular = 0.3f;
Shapes.Add(middle);
Shape right = new Sphere();
right.Transform = Transformation.Translation(1.5f, 0.5f, -0.5f) * Transformation.Scaling(0.5f, 0.5f, 0.5f);
right.Material.Color = Tuple.Color(0.5f, 1, 0.1f);
right.Material.Diffuse = 0.7f;
right.Material.Specular = 0.3f;
Shapes.Add(right);
Shape left = new Sphere();
left.Transform = Transformation.Translation(-1.5f, 0.33f, -0.75f) * Transformation.Scaling(0.33f, 0.33f, 0.33f);
left.Material.Color = Tuple.Color(1, 0.8f, 0.1f);
left.Material.Diffuse = 0.7f;
left.Material.Specular = 0.3f;
Shapes.Add(left);
Lights.Add(new PointLight(Tuple.Point(-10, 10, -10), Tuple.Color(1, 1, 1)));
}
/// <summary>
///
/// </summary>
/// <param name="lights"></param>
/// <returns>The Elements object.</returns>
public Elements AddLigths(List <Lights> lights)
{
foreach (var light in lights)
{
Lights.Add(light);
}
return(this);
}
public int AddLight(HueLight light)
{
var nextId = Lights.Count + 1;
light.Id = nextId;
Lights.Add(nextId, light);
return(nextId);
}
public Scene(PictureBox canvas)
{
this.canvas = canvas;
Camera = new Camera();
ResetCamera();
Cameras.Add(Camera);
Lights.Add(new Vector3D(0, 150, -150));
Light = Lights[0];
}
//-------------------------------------------------------------------------------------
// Unity Lifecycle Functions
//-------------------------------------------------------------------------------------
protected override void OnEnable()
{
Lights.Add(this);
if (_cullingGroup == null)
{
_cullingGroup = new CullingGroup();
RenderPipelineManager.beginCameraRendering += SetupCulling;
}
}
/// <summary>
/// Add new regions
/// </summary>
/// <param name="location"></param>
public void Add(PointF point)
{
var light = new StructLights();
light.Position = new K3DPosition(point.X, point.Y, 0f);
Lights.Add(light);
Added?.Invoke(this, light);
}
/// <summary>
/// Adds a light
/// </summary>
/// <param name="light">Handle</param>
public void AddLight(Light light)
{
if (light == null)
{
return;
}
Lights.Add(light);
}
/// <summary>
/// Adds the light.
/// </summary>
/// <param name="light">The light.</param>
public virtual void AddLight(ILight light)
{
if (light == null)
{
ActiveLogger.LogMessage("Cant Add null Light", LogLevel.RecoverableError);
return;
}
Lights.Add(light);
}
/// <summary>
/// Add new light
/// </summary>
/// <param name="vector"></param>
public void Add(Vector vector)
{
var light = new Light
{
Position = vector
};
Lights.Add(light);
Added?.Invoke(this, new AddedArgs(light, typeof(Light)));
}
protected override void Initialize()
{
base.Initialize();
PresentationParameters pp = GraphicsDevice.PresentationParameters;
width = pp.BackBufferWidth;
height = pp.BackBufferHeight;
// Camera Position und View-Vector festlegen
camera.Position = new Vector3(0.0f, 3.0f, 10.0f);
camera.LookAt(new Vector3(0.0f, 1.0f, 0.0f));
float sin = (float)Math.Sin(MathHelper.ToRadians(30.0f));
float cos = (float)Math.Cos(MathHelper.ToRadians(30.0f));
float lightHeight = 5.0f;
float lightRadius = 10.0f;
// Eigenschaften der Lichter setzen
lights.NearPlaneDistance = 2.0f;
lights.FarPlaneDistance = 20.0f;
lights.Speed = 0.5f;
lights.Add(0.0f, lightHeight, lightRadius);
lights.Add(cos * lightRadius, lightHeight, -sin * lightRadius);
lights.Add(-cos * lightRadius, lightHeight, -sin * lightRadius);
// Würfel und Pick-Ray auf unsichtbar setzen
cubes.Visible = false;
ray.Visible = false;
// Camera-Tracker deaktivieren
cameraTracker.Enabled = false;
// Antialiasing auf 4x setzen
GraphicsDevice.PresentationParameters.MultiSampleCount = 4;
}
async Task Init()
{
IsBusy = true;
var lights = await _lightService.GetLightsAsync();
foreach (var item in lights)
{
Lights.Add(item);
item.PropertyChanged += Item_PropertyChanged;
}
IsBusy = false;
}
internal override Region ReadEntry(BinaryReaderEx br)
{
RegionType type = br.GetEnum8 <RegionType>(br.Position + 0xA);
switch (type)
{
case RegionType.Region0:
var region0 = new Region.Region0(br);
Region0s.Add(region0);
return(region0);
case RegionType.Light:
var light = new Region.Light(br);
Lights.Add(light);
return(light);
case RegionType.StartPoint:
var startPoint = new Region.StartPoint(br);
StartPoints.Add(startPoint);
return(startPoint);
case RegionType.Sound:
var sound = new Region.Sound(br);
Sounds.Add(sound);
return(sound);
case RegionType.SFX:
var sfx = new Region.SFX(br);
SFXs.Add(sfx);
return(sfx);
case RegionType.Wind:
var wind = new Region.Wind(br);
Winds.Add(wind);
return(wind);
case RegionType.EnvLight:
var envLight = new Region.EnvLight(br);
EnvLights.Add(envLight);
return(envLight);
case RegionType.Fog:
var fog = new Region.Fog(br);
Fogs.Add(fog);
return(fog);
default:
throw new NotImplementedException($"Unimplemented region type: {type}");
}
}
/// <summary>
/// Load existing light
/// </summary>
/// <param name="buffer"></param>
public void Load(byte[] buffer)
{
try
{
using (MemoryReader mem = new MemoryReader(buffer))
{
Direction.X = mem.ReadSingle();
Direction.Y = mem.ReadSingle();
Direction.Z = mem.ReadSingle();
Specular = new KColor(mem.ReadByte(), mem.ReadByte(), mem.ReadByte(), mem.ReadByte());
Diffuse = new KColor(mem.ReadByte(), mem.ReadByte(), mem.ReadByte(), mem.ReadByte());
Ambient = new KColor(mem.ReadByte(), mem.ReadByte(), mem.ReadByte(), mem.ReadByte());
var lightCount = mem.ReadInt32();
for (int i = 0; i < lightCount; i++)
{
var light = new Light();
var vector = new Vector
{
X = mem.ReadSingle() / 7.875f,
Y = mem.ReadSingle() / 7.875f,
Z = mem.ReadSingle()
};
light.Position = vector.Rotate180FlipY();
light.Height = mem.ReadSingle();
light.Direction.X = mem.ReadSingle();
light.Direction.Y = mem.ReadSingle();
light.Direction.Z = mem.ReadSingle();
light.Specular = new KColor(mem.ReadByte(), mem.ReadByte(), mem.ReadByte(), mem.ReadByte());
light.Diffuse = new KColor(mem.ReadByte(), mem.ReadByte(), mem.ReadByte(), mem.ReadByte());
light.Ambient = new KColor(mem.ReadByte(), mem.ReadByte(), mem.ReadByte(), mem.ReadByte());
light.LightType = (LightsType)mem.ReadInt32();
Lights.Add(light);
}
}
Render();
Parent.Log(Levels.Success, "Ok\n");
}
catch (Exception exception)
{
Dispose();
Parent.Log(Levels.Error, "Failed\n");
Parent.Log(Levels.Fatal, string.Format("Nfl::Load<Exception> -> {0}\n", exception));
}
}
/// <summary>
/// empty constructor.
/// </summary>
public OpenGlDevice()
{
InitializeCtrlHandler();
OnTime = new EventHandler(Timer_Tick);
Camera = new Camera(this);
Light L = new Light();
L.Device = this;
Lights.Add(L);
ShadowSetting = new ShadowSettings(this);
Selector.Device = this;
if (Devices == null)
{
Devices = new List <OpenGlDevice>();
}
}
protected override void OnApplyTemplate()
{
base.OnApplyTemplate();
_rootGrid = GetTemplateChild <Grid>(PART_RootGrid);
_backgroundShadowContainer = GetTemplateChild <Rectangle>(PART_BackgroundShadowContainer);
_textShadowContainer = GetTemplateChild <Rectangle>(PART_TextShadowContainer);
_contentPresenter = GetTemplateChild <ContentPresenter>(PART_ContentPresenter);
_backgroundShadowContainer.SetDropShadow(_backgroundShadow);
_textShadowContainer.SetDropShadow(_textShadow);
Lights.Add(new HoverXamlLight());
Lights.Add(new AmbientXamlLight());
Lights.Add(new RippleXamlLight());
}
public Settings(IConfiguration configuration)
{
var server = configuration.GetSection("Server");
Host = server.GetValue <string>("host");
Port = server.GetValue <int>("port");
var section = configuration.GetSection("Tally");
var tallies = section.GetChildren();
foreach (var tally in tallies)
{
var setting = new TallySetting(tally);
Lights.Add(setting);
}
}
public PlaneScene()
{
Shape floor = new Plane();
floor.Material.Color = Tuple.Color(1, 0.9f, 0.9f);
floor.Material.Specular = 0;
Shapes.Add(floor);
Shape ceiling = new Plane();
ceiling.Transform = Transformation.Translation(0, 2.5f, 0) * Transformation.RotationZ(PI);
floor.Material.Color = Tuple.Color(1, 0.9f, 0.9f);
floor.Material.Specular = 0;
Shapes.Add(ceiling);
Shape middle = new Sphere();
middle.Transform = Transformation.Translation(-0.5f, 1, 0.5f);
middle.Material.Color = Tuple.Color(0.1f, 1, 0.5f);
middle.Material.Diffuse = 0.7f;
middle.Material.Specular = 0.3f;
Shapes.Add(middle);
Shape right = new Sphere();
right.Transform = Transformation.Translation(1.5f, 0, -0.5f) * Transformation.Scaling(0.5f, 0.5f, 0.5f);
right.Material.Color = Tuple.Color(0, 0, 0.7f);
right.Material.Diffuse = 0.7f;
right.Material.Specular = 0.3f;
Shapes.Add(right);
Shape left = new Sphere();
left.Transform = Transformation.Translation(-1.5f, 0.33f, -0.75f) * Transformation.Scaling(0.33f, 0.33f, 0.33f);
left.Material.Color = Tuple.Color(1, 0.2f, 0.1f);
left.Material.Diffuse = 0.7f;
left.Material.Specular = 0.3f;
Shapes.Add(left);
Lights.Add(new PointLight(Tuple.Point(-1, 1, -1), Tuple.Color(1, 1, 1)));
}
internal override Event ReadEntry(BinaryReaderEx br)
{
EventType type = br.GetEnum16 <EventType>(br.Position + 0xC);
switch (type)
{
case EventType.Light:
var light = new Event.Light(br);
Lights.Add(light);
return(light);
case EventType.Shadow:
var shadow = new Event.Shadow(br);
Shadows.Add(shadow);
return(shadow);
case EventType.Fog:
var fog = new Event.Fog(br);
Fogs.Add(fog);
return(fog);
case EventType.BGColor:
var bgColor = new Event.BGColor(br);
BGColors.Add(bgColor);
return(bgColor);
case EventType.MapOffset:
var mapOffset = new Event.MapOffset(br);
MapOffsets.Add(mapOffset);
return(mapOffset);
case EventType.Warp:
var warp = new Event.Warp(br);
Warps.Add(warp);
return(warp);
case EventType.CheapMode:
var cheapMode = new Event.CheapMode(br);
CheapModes.Add(cheapMode);
return(cheapMode);
default:
throw new NotImplementedException($"Unimplemented event type: {type}");
}
}
public DefaultWorld()
{
Lights.Add(new PointLight(Tuple.Point(-10, 10, -10), Tuple.Color(1, 1, 1)));
Shape s1 = new Sphere();
s1.Material.Color = Tuple.Color(0.8f, 1, 0.6f);
s1.Material.Diffuse = 0.7f;
s1.Material.Specular = 0.2f;
Shapes.Add(s1);
Shape s2 = new Sphere();
s2.Transform = Transformation.Scaling(0.5f, 0.5f, 0.5f);
Shapes.Add(s2);
}
private void LoadLights()
{
for (var i = 0u; i < Core.scenario_get_point_light_count(Handle); ++i)
{
Lights.Add(Core.scenario_get_light_handle(Handle, (int)i, Core.LightType.Point));
}
for (var i = 0u; i < Core.scenario_get_spot_light_count(Handle); ++i)
{
Lights.Add(Core.scenario_get_light_handle(Handle, (int)i, Core.LightType.Spot));
}
for (var i = 0u; i < Core.scenario_get_dir_light_count(Handle); ++i)
{
Lights.Add(Core.scenario_get_light_handle(Handle, (int)i, Core.LightType.Directional));
}
if (Core.scenario_has_envmap_light(Handle))
{
Lights.Add(Core.scenario_get_light_handle(Handle, 0, Core.LightType.Envmap));
}
}
