public override void Initialize()
{
this.interactionTexture = ResourceManager.Instance.LoadTexture(@"Textures/HUD/x_button");
this.noteTexture = ResourceManager.Instance.LoadTexture(@"Textures/Storyline/note");
myPoint = new LightPoint(110, "LightPoint1", Color.Blue.ToVector3(), Color.Blue.ToVector3(), 6.0f, false);
MyObject.AddChild(myPoint);
myPoint.MyTransform = new Transform(myPoint, new Vector3(0.0f, 0.25f, 0.0f), new Vector3(0.0f, 1.0f, 0.0f), new Vector3(0.0f, 0.0f, 0.0f), 1.0f);
myPoint.MyCollider = new SphereCollider(myPoint, true);
myPoint.MyCollider.CustomScale = new Vector3(5.0f, 0.0f, 0.0f);
myPoint.MyPhysicalObject = new PhysicalObject(myPoint, 0.0f, 0.0f, false);
ResourceManager.Instance.CurrentScene.PointLights.Add(myPoint);
foreach (GameObject obj in ResourceManager.Instance.CurrentScene.ObjectsDictionary.Values)
{
if (obj.Name.Contains("Street") && !obj.LightsAffecting.Contains(myPoint) &&
Vector3.Distance(MyObject.MyTransform.PositionGlobal, obj.MyTransform.PositionGlobal) <= 20.0f)
{
myPoint.AffectedObjects.Add(obj);
obj.LightsAffecting.Add(myPoint);
}
}
base.Initialize();
}
private float lightValueAtFromPoint(PTwo destinationPoint, LightPoint fromPoint)
{
PTwo diff = PTwo.Abs(destinationPoint - fromPoint.point);
int dist = diff.s + diff.t / 2; // very cheapo pythagoras
return(lightAddedWithDistance(dist, fromPoint.lightValue));
}
///-------------------------------------------------------------------------------------------------
/// <summary> Main entry-point for this application. </summary>
///
/// <remarks> Kemp, 12/5/2018. </remarks>
///
/// <param name="args"> An array of command-line argument strings. </param>
///-------------------------------------------------------------------------------------------------
static void Main(string[] args)
{
/// where we are looking from
Point eyep = new Point(0, 0, -5);
/// define the sphere
Sphere s = new Sphere();
s.Material = new Material();
s.Material.Color = new Color(1, 0.2, 1);
//s.Transform = RTMatrixOps.Scaling(1, 0.5, 1);
s.Material.Pattern = new Checked3DPattern(new Color(0, 0, 0), new Color(1, 1, 1));
s.Material.Pattern.Transform = MatrixOps.CreateScalingTransform(0.2, 0.2, 0.2);
s.Transform = MatrixOps.CreateRotationYTransform(Math.PI / 4);
/// define the light
Point lightPos = new Point(-10, 10, -10);
Color lightColor = new Color(1, 1, 1);
LightPoint light = new LightPoint(lightPos, lightColor);
/// Calculate canvas size and resolution
const uint canvasResolution = 256;
const uint canvasZ = 10;
RayTracerLib.Vector tangentRay = (new Point(0, 1, 0) - eyep).Normalize();
double canvasSize = ((tangentRay * (canvasZ - eyep.Z)).Y * 1.1) * 2;
Point canvasOrigin = new Point(-canvasSize / 2.0, -canvasSize / 2.0, canvasZ);
Canvas c = new Canvas(canvasResolution, canvasResolution);
//now loop collecting canvas points.
Point canvaspoint = new Point(0, 0, 10);
Color red = new Color(255, 0, 0);
for (int iy = 0; iy < canvasResolution; iy++)
{
for (int ix = 0; ix < canvasResolution; ix++)
{
canvaspoint.X = (double)ix * canvasSize / canvasResolution + canvasOrigin.X;
canvaspoint.Y = (double)iy * canvasSize / canvasResolution + canvasOrigin.Y;
RayTracerLib.Vector rayv = (canvaspoint - eyep).Normalize();
Ray r = new Ray(eyep, rayv);
List <Intersection> xs = s.Intersect(r);
if (xs.Count != 0)
{
Intersection hit = xs[0];
Point hitpoint = r.Position(hit.T);
RayTracerLib.Vector normal = ((Sphere)hit.Obj).NormalAt(hitpoint);
Color phong = Ops.Lighting(((Sphere)hit.Obj).Material, hit.Obj, light, hitpoint, -rayv, normal);
c.WritePixel((uint)ix, (uint)iy, phong);
}
}
}
String ppm = c.ToPPM();
System.IO.File.WriteAllText(@"ToPPM.ppm", ppm);
Console.Write("Press Enter to finish ... ");
Console.Read();
}
void Start()
{
lightPoint = new LightPoint();
lightPoint.SetSize(12);
lightPoint.SetPosition(transform.position);
this.Inject();
}
void Start()
{
viewReciver = GetComponent <UnitViewReciver>();
pysicItem = viewReciver.pysicItem;
lightPoint = new LightPoint();
lightPoint.SetSize(32);
}
public void RemoveMyPointLight()
{
if (myPoint == null)
{
return;
}
ResourceManager.Instance.CurrentScene.RemovePointLight(myPoint);
myPoint = null;
}
static void Main(string[] args)
{
{
Sphere s = new Sphere();
RayTracerLib.Vector n = s.NormalAt(new Point(1, 0, 0));
bool foo = n.Equals(new RayTracerLib.Vector(1, 0, 0));
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~");
}
{
Sphere s = new Sphere();
Material m = s.Material;
bool foo = m.Equals(new Material());
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~");
}
{
Material m = new Material();
Point position = new Point();
RayTracerLib.Vector eyev = new RayTracerLib.Vector(0, 0, -1);
RayTracerLib.Vector normalv = new RayTracerLib.Vector(0, 0, -1);
Sphere s = new Sphere();
LightPoint light = new LightPoint(new Point(0, 0, -10), new Color(1, 1, 1));
Color result = Ops.Lighting(m, s, light, position, eyev, normalv);
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~");
}
{
Material m = new Material();
Point position = new Point();
RayTracerLib.Vector eyev = new RayTracerLib.Vector(0, Math.Sqrt(2) / 2, -Math.Sqrt(2) / 2);
RayTracerLib.Vector normalv = new RayTracerLib.Vector(0, 0, -1);
Sphere s = new Sphere();
LightPoint light = new LightPoint(new Point(0, 0, -10), new Color(1, 1, 1));
Color result = Ops.Lighting(m, s, light, position, eyev, normalv);
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~");
}
{
//SphereNormalScaled() {
Sphere s = new Sphere();
s.Transform = MatrixOps.CreateScalingTransform(1, 1, 1);
Point p = new Point(0, Math.Sqrt(2) / 2, -Math.Sqrt(2) / 2);
RayTracerLib.Vector n = s.NormalAt(p);
bool foo = (n.Equals(new RayTracerLib.Vector(0, 0.97014, -0.24254)));
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~");
}
Console.Write("Press Enter to finish ... ");
Console.Read();
}
public void PointInterationDoesNotChangeVelocity()
{
var point = new LightPoint {
xPosition = 100, yPosition = 200, xVelocity = -25, yVelocity = -50
};
point.Iterate(Direction.forward);
Assert.Equal(-25, point.xVelocity);
Assert.Equal(-50, point.yVelocity);
}
public async Task UpdateLightPoint(LightPoint lightPoint)
{
try
{
_context.LightPoint.Update(lightPoint);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public void PointInteratesUsingVelocity()
{
var point = new LightPoint {
xPosition = 100, yPosition = 200, xVelocity = -25, yVelocity = -50
};
point.Iterate(Direction.forward);
Assert.Equal(75, point.xPosition);
Assert.Equal(150, point.yPosition);
}
private void OnTriggerEnter(Collider other)
{
LightPoint post = other.GetComponentInParent <LightPoint>();
if (other.tag == "LightPoint" && post != null && post.isEnabled)
{
_isInLight = true;
}
else if (other.tag == "ShadePoint")
{
UpdateShadeState(true);
}
}
public int Comparer(LightPoint a, LightPoint b)
{
if (a == null || b == null)
{
return(0);
}
if (Vector3.Distance(a.GetPosition(), transform.position) > Vector3.Distance(b.GetPosition(), transform.position))
{
return(1);
}
else
{
return(-1);
}
}
public void updateWithXAdjacentPoint(LightPoint lightPoint)
{
lightPoint.lightValue -= Window.UNIT_FALL_OFF;
lightPoint.lightValue = lightPoint.lightValue < 0f ? 0f : lightPoint.lightValue;
float[] currentValues = trapLight.clockWiseValues();
PTwo[] currentPoints = trapezoid.clockwisePoints();
for (int i = 0; i < 4; ++i)
{
float addedLight = lightValueAtFromPoint(currentPoints[i], lightPoint);
float newValue = incrementedLightValue(currentValues[i], addedLight);
trapLight.setValueWithClockwiseIndex(newValue, i);
// trapLight.setValueWithClockwiseIndex(Window.LIGHT_LEVEL_MAX, i); // TEST
}
}
protected override void Initialize()
{
this.Window.Title = "SharpEngine v0.1 [F1 for Editor]";
this.Window.AllowUserResizing = true;
this.IsFixedTimeStep = false;
this.IsMouseVisible = false;
//create and register components
this.Components.Add(InputMgr.Create(this));
this.Components.Add(EntityMgr.Create(this));
this.Components.Add(GraphicsMgr.Create(this));
this.Components.Add(ResourceMgr.Create(this));
this.Components.Add(Editor.Create(this));
base.Initialize();
//HACK create our main free camera
FreeCamera freecam = new FreeCamera();
freecam.Name = "MainCamera";
EntityMgr entityMgr = EntityMgr.Instance;
entityMgr.AddEntity(freecam);
GraphicsMgr.Instance.Camera = freecam;
Light light = new LightPoint();
light.Name = "Light0";
light.ID = 1;
entityMgr.AddEntity(light);
light = new LightPoint();
light.Name = "Light1";
light.ID = 2;
entityMgr.AddEntity(light);
light = new LightPoint();
light.Name = "Light2";
light.ID = 3;
entityMgr.AddEntity(light);
light = new LightDirectionnal();
light.Name = "Light3";
light.ID = 4;
entityMgr.AddEntity(light);
}
private async Task UserConnected(string payload)
{
//TODO try catch serializer can crash
LightPoint lightPointSwitch = JsonConvert.DeserializeObject <LightPoint>(payload);
try
{
var lightPoint = await _restClient.GetLightPoints(Guid.Parse(lightPointSwitch.Id));
if (lightPoint.CustomName == null)
{
var lightBulb = new List <LightBulbDto>();
foreach (var id in lightPointSwitch.BulbsId)
{
lightBulb.Add(new LightBulbDto()
{
Id = Guid.Parse(id)
});
}
var lightPointDto = new LightPointDto()
{
CustomName = lightPointSwitch.CustomName,
Id = Guid.Parse(lightPointSwitch.Id),
LightBulbs = lightBulb
};
//TODO auto generation of guid and saving to memeory of rPi
await _restClient.AddLightPoint(Guid.Parse(_homeAutomationLocalLightSystemId), lightPointDto);
}
else
{
await _restClient.EnableLightPoint(Guid.Parse(lightPointSwitch.Id));
}
}
catch (Exception ex)
{
await _logger.SendMessage($"Lighting System {ex}", LogLevel.Error);
await _lokiLogger.SendMessage($"Lighting System {ex}", LogLevel.Error);
Console.WriteLine(ex);
}
}
public override void Initialize()
{
myPoint = new LightPoint(110, "LightPoint1", Color.Green.ToVector3(), Color.Green.ToVector3(), 10.0f, false);
MyObject.AddChild(myPoint);
myPoint.MyTransform = new Transform(myPoint, new Vector3(0.0f, 0.25f, 0.0f), new Vector3(0.0f, 1.0f, 0.0f), new Vector3(0.0f, 0.0f, 0.0f), 4.0f);
myPoint.MyCollider = new SphereCollider(myPoint, true);
myPoint.MyCollider.CustomScale = new Vector3(6.0f, 0.0f, 0.0f);
myPoint.MyPhysicalObject = new PhysicalObject(myPoint, 0.0f, 0.0f, false);
ResourceManager.Instance.CurrentScene.PointLights.Add(myPoint);
foreach (GameObject obj in ResourceManager.Instance.CurrentScene.ObjectsDictionary.Values)
{
if (obj.Name.Contains("Street") && !obj.LightsAffecting.Contains(myPoint) &&
Vector3.Distance(MyObject.MyTransform.PositionGlobal, obj.MyTransform.PositionGlobal) <= 25.0f)
{
myPoint.AffectedObjects.Add(obj);
obj.LightsAffecting.Add(myPoint);
}
}
base.Initialize();
}
public static string Day6(string input)
{
string output = "";
if (noInput(input))
{
output = NOINPUT;
return output;
}
string[] instructions = input.Split('\n');
LightPoint[] lightGrid = new LightPoint[(int)10e5];
int index = 0;
for (int x = 0; x < 1000; x++)
{
for (int y = 0; y < 1000; y++)
{
lightGrid[index] = new LightPoint(false, new Point(x,y));
index++;
}
}
foreach (string instruction in instructions)
{
if (instruction.StartsWith("turn off"))
lightGrid = turnOffRange(lightGrid, getRange(instruction));
if (instruction.StartsWith("toggle"))
lightGrid = toggleRange(lightGrid, getRange(instruction));
if (instruction.StartsWith("turn on"))
lightGrid = turnOnRange(lightGrid, getRange(instruction));
}
output += "The number of lights that are lit is: " + lightGrid.Count(x => x.isLit == true) + "\n The total brightness of the grid is: " + lightGrid.Sum(x => x.brightness);
return output;
}
public override void Load(BinaryReader reader, int size)
{
//long start_pos = reader.BaseStream.Position;
HeaderUnk1 = reader.ReadUInt32();
uint chunkNameLength = reader.ReadUInt32();
ChunkName = new string(reader.ReadChars((int)chunkNameLength));
HeaderUnk2 = reader.ReadUInt32();
HeaderUnk3 = reader.ReadUInt32();
HeaderUnk4 = reader.ReadByte();
if ((HeaderUnk1 & 0x10000) != 0)
{
SkydomeID = reader.ReadUInt32();
}
LightsAmbient = new List <LightAmbient>();
LightsDirectional = new List <LightDirectional>();
LightsPoint = new List <LightPoint>();
LightsNegative = new List <LightNegative>();
if ((HeaderUnk1 & 0x20000) != 0)
{
HeaderBuffer = reader.ReadBytes(0x400);
uint LightsNum = reader.ReadUInt32();
uint LightAmbientNum = reader.ReadUInt32();
uint LightDirectionalNum = reader.ReadUInt32();
uint LightPointNum = reader.ReadUInt32();
uint LightNegativeNum = reader.ReadUInt32();
if (LightAmbientNum > 0)
{
for (int i = 0; i < LightAmbientNum; i++)
{
LightAmbient light = new LightAmbient();
light.Flags = reader.ReadBytes(4);
light.Radius = reader.ReadSingle();
light.Color_R = reader.ReadSingle();
light.Color_G = reader.ReadSingle();
light.Color_B = reader.ReadSingle();
light.Color_Unk = reader.ReadSingle();
light.Position = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
light.Vector1 = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
light.Vector2 = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
LightsAmbient.Add(light);
}
}
if (LightDirectionalNum > 0)
{
for (int i = 0; i < LightDirectionalNum; i++)
{
LightDirectional light = new LightDirectional();
light.Flags = reader.ReadBytes(4);
light.Radius = reader.ReadSingle();
light.Color_R = reader.ReadSingle();
light.Color_G = reader.ReadSingle();
light.Color_B = reader.ReadSingle();
light.Color_Unk = reader.ReadSingle();
light.Position = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
light.Vector1 = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
light.Vector2 = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
light.Vector3 = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
light.unkShort = reader.ReadUInt16();
LightsDirectional.Add(light);
}
}
if (LightPointNum > 0)
{
for (int i = 0; i < LightPointNum; i++)
{
LightPoint light = new LightPoint();
light.Flags = reader.ReadBytes(4);
light.Radius = reader.ReadSingle();
light.Color_R = reader.ReadSingle();
light.Color_G = reader.ReadSingle();
light.Color_B = reader.ReadSingle();
light.Color_Unk = reader.ReadSingle();
light.Position = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
light.Vector1 = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
light.Vector2 = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
light.unkShort = reader.ReadUInt16();
LightsPoint.Add(light);
}
}
if (LightNegativeNum > 0)
{
for (int i = 0; i < LightNegativeNum; i++)
{
LightNegative light = new LightNegative();
light.Flags = reader.ReadBytes(4);
light.Radius = reader.ReadSingle();
light.Color_R = reader.ReadSingle();
light.Color_G = reader.ReadSingle();
light.Color_B = reader.ReadSingle();
light.Color_Unk = reader.ReadSingle();
light.Position = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
light.Vector1 = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
light.Vector2 = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
light.Vector3 = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
light.unkFloat1 = reader.ReadSingle();
light.unkFloat2 = reader.ReadSingle();
light.unkUInt1 = reader.ReadUInt32();
light.unkUInt2 = reader.ReadUInt32();
light.unkUShort1 = reader.ReadUInt16();
light.unkUShort2 = reader.ReadUInt16();
LightsNegative.Add(light);
}
}
}
SceneryRoot = null;
if (HeaderUnk3 == 0x160A)
{
unkVar5 = reader.ReadUInt32();
SceneryRoot = LoadScenery(reader);
}
else
{
//Console.WriteLine("no scenery!! bug?");
}
//Console.WriteLine("end pos: " + (reader.BaseStream.Position - start_pos) + " target: " + size);
}
public LightRayInfo(Vector3 rayDirction, Vector3 vertiex, LightPoint lightPoint)
{
this.rayDirction = rayDirction;
this.vertiex = vertiex;
this.lightPoint = lightPoint;
}
public void ReloadObjMap(string[] pMapObjFile)
{
MapObjects.Clear();
LightPoints.Clear();
foreach (var obj in pMapObjFile)
{
if (obj.Length < 2)
{
continue;
}
string[] LineArgs = obj.Split(';');
int TileX = Convert.ToInt32(LineArgs[0]) * Global.TileSize;
int TileY = Convert.ToInt32(LineArgs[1]) * Global.TileSize;
string[] TileProperties = LineArgs[2].Split(',');
MapTile ThisTile = new MapTile(TileX, TileY, TileProperties, MapObjects.Count);
if (ThisTile.ObjectTileIDType != -1)
{
if (ThisTile.ObjectTileIDType == 1)
{
CurrentPlayer = new Player(TileX, TileY, this);
}
if (ThisTile.ObjectTileIDType == 2)
{
//ScriptTrigger Stta = new ScriptTrigger(ThisTile.TileArgs, TileX, TileY, MapView);
string ParsedScriptName = "";
string ParsedEventName = "";
string ParsedID = "";
bool ParsedColideable = false;
bool ActivateViaActionKey = false;
string ParsedColideableSprite = "";
for (int i = 0; i < TileProperties.Length; i++)
{
string[] Parameter = TileProperties[i].Split(':');
switch (Parameter[0])
{
case "script_name":
ParsedScriptName = Parameter[1];
break;
case "event_name":
ParsedEventName = Parameter[1];
break;
case "script_id":
ParsedID = Parameter[1];
break;
case "script_colideable":
ParsedColideable = true;
break;
case "colideable_sprite":
ParsedColideableSprite = Parameter[1];
break;
case "action_key":
ActivateViaActionKey = true;
break;
}
}
ScriptTrigger Stta = new ScriptTrigger(ParsedScriptName, ParsedEventName, ParsedColideable, ParsedColideableSprite, ParsedID, ActivateViaActionKey, TileX, TileY, MapView);
MapObjects.Add(Stta);
}
if (ThisTile.ObjectTileIDType == 4)
{
LightPoint LightPointToAdd = new LightPoint(this, TileX, TileY, 10, "default");
int ParsedLightRadius = 100;
string ParsedLightShape = "default";
for (int i = 0; i < TileProperties.Length; i++)
{
string[] Parameter = TileProperties[i].Split(':');
switch (Parameter[0])
{
case "light_radius":
ParsedLightRadius = Convert.ToInt32(Parameter[1]);
break;
case "light_shape":
ParsedLightShape = Parameter[1];
break;
}
}
LightPointToAdd.Radius = ParsedLightRadius;
LightPointToAdd.SetLightShape(ParsedLightShape);
LightPoints.Add(LightPointToAdd);
}
}
}
}
private static LightPoint[] turnOnRange(LightPoint[] list, Range range)
{
for (int i = 0; i < (int)10e5; i++)
{
if (list[i].location.X >= range.xMin &&
list[i].location.X <= range.xMax &&
list[i].location.Y >= range.yMin &&
list[i].location.Y <= range.yMax)
{
list[i].isLit = true;
list[i].brightness = list[i].brightness + 1;
if (list[i].brightness <= 0) list[i].brightness = 0;
}
}
return list;
}
private static Vector2 GetLightClippingPlanes(LightPoint pointLight)
{
// Note: we don't take exactly the required depth range since this will result in a very poor resolution in most of the light's range
return(new Vector2(0.1f, pointLight.Radius * 2));
}
///-------------------------------------------------------------------------------------------------
/// <summary> Main entry-point for this application. </summary>
///
/// <remarks> Kemp, 1/18/2019. </remarks>
///
/// <param name="args"> An array of command-line argument strings. </param>
///-------------------------------------------------------------------------------------------------
static void Main(string[] args)
{
World defaultWorld = new World();
defaultWorld.AddLight(new LightPoint(new Point(-10, 10, -10), new Color(1, 1, 1)));
Sphere s1 = new Sphere();
s1.Material = new Material();
s1.Material.Color = new Color(0.8, 1.0, 0.6);
s1.Material.Diffuse = new Color(0.7, 0.7, 0.7);
s1.Material.Specular = new Color(0.2, 0.2, 0.2);
Sphere s2 = new Sphere();
s2.Transform = MatrixOps.CreateScalingTransform(0.5, 0.5, 0.5);
defaultWorld.AddObject(s1);
defaultWorld.AddObject(s2);
Color white = new Color(1, 1, 1);
Color black = new Color(0, 0, 0);
Sphere s = new Sphere();
{
Material m = new Material();
m.Pattern = new StripePattern(white, black);
m.Ambient = new Color(1, 1, 1);
m.Diffuse = new Color(0, 0, 0);
m.Specular = new Color(0, 0, 0);
m.Shininess = 0;
RayTracerLib.Vector eyev = new RayTracerLib.Vector(0, 0, -1);
RayTracerLib.Vector normalv = new RayTracerLib.Vector(0, 0, -1);
Point p1 = new Point(0.9, 0, 0);
Point p2 = new Point(1.1, 0, 0);
LightPoint light = new LightPoint(new Point(0, 0, -10), new Color(1, 1, 1));
Color c1 = Ops.Lighting(m, s, light, p1, eyev, normalv, false);
Color c2 = Ops.Lighting(m, s, light, p2, eyev, normalv, false);
bool foo1 = (c1.Equals(white));
bool foo2 = (c2.Equals(black));
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~");
}
//public void PatternWithObjectTransformation()
{
Shape shape = new Sphere()
{
Transform = MatrixOps.CreateScalingTransform(2, 2, 2)
};
Pattern pattern = new TestPattern {
Transform = MatrixOps.CreateTranslationTransform(0.5, 1, 1.5)
};
Color c = pattern.PatternAtObject(shape, new Point(2.5, 3, 3.5));
bool foo1 = (c.Equals(new Color(0.75, 0.5, 0.25)));
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~");
}
//public void GradientInterpolates()
{
Pattern pattern = new GradientPattern(black, white);
bool foo1 = (pattern.PatternAt(new Point(0, 0, 0)).Equals(black));
bool foo2 = (pattern.PatternAt(new Point(0.25, 0, 0)).Equals(new Color(0.25, 0.25, 0.25)));
bool foo3 = (pattern.PatternAt(new Point(0.5, 0, 0)).Equals(new Color(0.5, 0.5, 0.5)));
bool foo4 = (pattern.PatternAt(new Point(0.75, 0, 0)).Equals(new Color(0.75, 0.75, 0.75)));
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~");
}
{
Pattern pattern = new CheckedPattern(black, white);
bool foo1 = (pattern.PatternAt(new Point(0, 0, 0)).Equals(black));
bool foo2 = (pattern.PatternAt(new Point(0.99, 0, 0)).Equals(black));
bool foo3 = (pattern.PatternAt(new Point(1.01, 0, 0)).Equals(white));
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~");
}
Console.Write("Press Enter to finish ... ");
Console.Read();
}
private Vector2 GetLightClippingPlanes(LightPoint pointLight)
{
return(new Vector2(0.0f, pointLight.Radius + 2.0f));
}
public override void Initialize()
{
if (type != WeaponType.FISTS)
{
myPoint = new LightPoint(110, "LightPoint1", Color.Orange.ToVector3(), Color.Orange.ToVector3(), 6.0f, false);
MyObject.AddChild(myPoint);
myPoint.MyTransform = new Transform(myPoint, new Vector3(0.0f, 0.25f, 0.0f), new Vector3(0.0f, 1.0f, 0.0f), new Vector3(0.0f, 0.0f, 0.0f), 1.0f);
myPoint.MyCollider = new SphereCollider(myPoint, true);
myPoint.MyCollider.CustomScale = new Vector3(5.0f, 0.0f, 0.0f);
myPoint.MyPhysicalObject = new PhysicalObject(myPoint, 0.0f, 0.0f, false);
ResourceManager.Instance.CurrentScene.PointLights.Add(myPoint);
foreach (GameObject obj in ResourceManager.Instance.CurrentScene.ObjectsDictionary.Values)
{
if (obj.Name.Contains("Street") && !obj.LightsAffecting.Contains(myPoint) &&
Vector3.Distance(MyObject.MyTransform.PositionGlobal, obj.MyTransform.PositionGlobal) <= 20.0f)
{
myPoint.AffectedObjects.Add(obj);
obj.LightsAffecting.Add(myPoint);
}
}
}
this.player = ResourceManager.Instance.CurrentScene.GetObject(1);
if (this.player != null)
{
this.pc = (PlayerController)this.player.GetComponent <PlayerController>();
}
if (ParticleTexturePaths != null && ParticleTexturePaths.Count() != 0)
{
int pCount = ParticleTexturePaths.Count();
GameObject dupa = new GameObject(132453245, "asfoieasjhgeowisughasaedokfgheasiourfdseyhaeyogfiuhsweoiughdseifoluh");
ps = new ParticleSystem(this.MyObject);
for (int i = 0; i < pCount; ++i)
{
ps.Textures.Add(ResourceManager.Instance.LoadTexture(ParticleTexturePaths[i]));
}
ps.ParticleCount = 20;
ps.ParticleSize = new Vector2(0.3f, 0.3f);
ps.ParticleSizeVariation = new Vector2(0.2f, 0.2f);
ps.LifespanSec = 0.8f;
ps.Wind = new Vector3(0.0f, 0.0f, 0.0f);
ps.Offset = new Vector3(MathHelper.Pi);
ps.Speed = 2.0f;
ps.RotationMode = ParticleSystem.ParticleRotationMode.DIRECTION_Z;
ps.ParticleRotation = new Vector3(0.0f, 0.0f, MathHelper.PiOver4);
ps.FadeInTime = 0.0f;
ps.FadeOutTime = 0.05f;
//ps.PositionOffset = new Vector3(0.0f, -1.0f, 0.0f) * MyObject.MyTransform.Scale;
ps.BlendMode = BlendState.AlphaBlend;
ps.UseGravity = true;
ps.Mass = 0.00000005f;
ps.Initialize();
ps.Stop();
dupa.Components.Add(ps);
dupa.MyTransform = new Transform(dupa);
MyObject.AddChild(dupa);
}
cModel = (CustomModel)MyObject.GetComponent <CustomModel>();
if (DestroyCueName != null && !TrashSoupGame.Instance.EditorMode)
{
jeb = Engine.AudioManager.Instance.SoundBank.GetCue(DestroyCueName);
}
base.Initialize();
}
