/// <summary>
/// Chooses one of two vectors depending on the <paramref name="pick1"/> value.
/// </summary>
/// <param name="v1">The first vector to choose.</param>
/// <param name="v2">The second vector to choose.</param>
/// <param name="pick1">If this value is true, the method chooses the virst vector, otherwise it chooses the second one.</param>
/// <returns>The selected vector.</returns>
public static Vector3F Select(Vector3F v1, Vector3F v2, bool pick1)
{
return(pick1 ? v1 : v2);
}
public EnvironmentTextureData(Component_Image texture, ref Matrix3F rotation, ref Vector3F multiplier)
{
this.texture = texture;
this.rotation = rotation;
this.multiplier = multiplier;
}
//
/// <summary>
/// Constructs a cone with another specified <see cref="ConeF"/> object.
/// </summary>
/// <param name="source">A specified cone.</param>
public ConeF(ConeF source)
{
Origin = source.Origin;
Axis = source.Axis;
Angle = source.Angle;
}
public RangeVector3F(Vector3F minimum, Vector3F maximum)
{
this.Minimum = minimum;
this.Maximum = maximum;
}
public virtual void GetRandomVariation(GetRandomVariationOptions options, Random random, out byte groupIndex, out byte elementIndex, out double positionZ, out QuaternionF rotation, out Vector3F scale)
{
//!!!!CompiledData?
if (options.SetGroup.HasValue)
{
groupIndex = options.SetGroup.Value;
}
else
{
groupIndex = 0;
}
elementIndex = 0;
positionZ = 0;
rotation = QuaternionF.Identity;
scale = Vector3F.One;
bool handled = false;
GetRandomVariationEvent?.Invoke(this, options, ref handled, ref groupIndex, ref elementIndex);
if (handled)
{
return;
}
var groups = GetComponents <Component_SurfaceGroupOfElements>();
if (groups.Length != 0)
{
if (!options.SetGroup.HasValue)
{
var groupProbabilities = new double[groups.Length];
for (int n = 0; n < groupProbabilities.Length; n++)
{
if (groups[n].Enabled)
{
groupProbabilities[n] = groups[n].Probability;
}
}
groupIndex = (byte)GetRandomIndex(random, groupProbabilities);
}
if (groupIndex < groups.Length)
{
var group = groups[groupIndex];
var groupElements = group.GetComponents <Component_SurfaceElement>();
if (groupElements.Length != 0)
{
var elementProbabilities = new double[groupElements.Length];
for (int n = 0; n < elementProbabilities.Length; n++)
{
if (groupElements[n].Enabled)
{
elementProbabilities[n] = groupElements[n].Probability;
}
}
elementIndex = (byte)GetRandomIndex(random, elementProbabilities);
}
//PositionZRange
var positionZRange = group.PositionZRange.Value;
if (positionZRange.Minimum != positionZRange.Maximum)
{
positionZ = random.Next(positionZRange.Minimum, positionZRange.Maximum);
}
else
{
positionZ = positionZRange.Minimum;
}
//RotateAroundItsAxis
if (group.RotateAroundItsAxis)
{
rotation *= Quaternion.FromRotateByZ(random.Next(0, MathEx.PI * 2)).ToQuaternionF();
}
//MaxIncline
if (group.MaxIncline.Value != 0)
{
var incline = random.Next(group.MaxIncline.Value.InRadians());
rotation *= QuaternionF.FromRotateByX((float)incline);
}
//ScaleRange
var scaleRange = group.ScaleRange.Value;
float scaleV;
if (scaleRange.Minimum != scaleRange.Maximum)
{
scaleV = (float)random.Next(scaleRange.Minimum, scaleRange.Maximum);
}
else
{
scaleV = (float)scaleRange.Minimum;
}
scale = new Vector3F(scaleV, scaleV, scaleV);
}
}
}
public ColorByte(Vector3F color)
: this((int)(color.X * 255), (int)(color.Y * 255), (int)(color.Z * 255))
{
}
public static bool DetectTextureType(byte[] data, Vector2I size, PixelFormat format, out bool hasAlpha, out bool normalMap)
{
hasAlpha = false;
normalMap = size.X > 64 && size.Y > 64;
int normalMapCount = 0;
int totalCount = 0;
for (int y = 0; y < size.Y; y++)
{
for (int x = 0; x < size.X; x++)
{
byte r;
byte g;
byte b;
byte a = 255;
int offset;
switch (format)
{
case PixelFormat.R8G8B8A8:
offset = (y * size.X + x) * 4;
r = data[offset + 3];
g = data[offset + 2];
b = data[offset + 1];
a = data[offset + 0];
break;
case PixelFormat.R8G8B8:
offset = (y * size.X + x) * 3;
r = data[offset + 2];
g = data[offset + 1];
b = data[offset + 0];
break;
case PixelFormat.X8R8G8B8:
offset = (y * size.X + x) * 4;
r = data[offset + 2];
g = data[offset + 1];
b = data[offset + 0];
break;
case PixelFormat.A8R8G8B8:
offset = (y * size.X + x) * 4;
a = data[offset + 3];
r = data[offset + 2];
g = data[offset + 1];
b = data[offset + 0];
break;
default:
hasAlpha = false;
normalMap = false;
return(false);
}
if (a != 255)
{
hasAlpha = true;
}
if (normalMap)
{
var v = new Vector3F(r, g, b) / 255.0f;
v *= 2;
v -= new Vector3F(1, 1, 1);
var l = v.Length();
if (l > 0.75f && l < 1.25f)
{
normalMapCount++;
}
else
{
if (totalCount > 10000)
{
float p = (float)normalMapCount / totalCount;
if (p < .95f)
{
normalMap = false;
}
}
}
}
totalCount++;
}
}
if (normalMap)
{
float p = (float)normalMapCount / totalCount;
if (p < .95f)
normalMap = false; }
}
public SphereF(Vector3F origin, float radius)
{
this.Origin = origin;
this.Radius = radius;
}
//private void Pipeline_RenderBegin( Component_RenderingPipeline_Basic sender, ViewportRenderingContext context, Component_RenderingPipeline_Basic.FrameData frameData )
//{
// if( EnabledInHierarchy && sender.UseRenderTargets )
// {
// //frameData.GenerateIBLSpecularTexture = true;
// //frameData.DeferredSpecularIBLItensity = 1.0 - Intensity;
// }
//}
private void Pipeline_RenderDeferredShadingEnd(Component_RenderingPipeline_Basic sender, ViewportRenderingContext context, Component_RenderingPipeline_Basic.FrameData frameData, ref Component_Image sceneTexture)
{
if (EnabledInHierarchy && sender.GetUseMultiRenderTargets())
{
var actualTexture = sceneTexture;
var pipeline = (Component_RenderingPipeline_Basic)context.RenderingPipeline;
Vector3 cameraPos = context.Owner.CameraSettings.Position;
//!!!!double
Vector3F cameraPosition = cameraPos.ToVector3F();
//!!!!double
Matrix4F projectionMatrix = context.Owner.CameraSettings.ProjectionMatrix.ToMatrix4F();
Matrix4F viewMatrix = context.Owner.CameraSettings.ViewMatrix.ToMatrix4F();
Matrix4F viewProjMatrix = projectionMatrix * viewMatrix;
Matrix4F invViewProjMatrix = viewProjMatrix.GetInverse();
float aspectRatio = (float)context.Owner.CameraSettings.AspectRatio;
float fov = (float)context.Owner.CameraSettings.FieldOfView;
float zNear = (float)context.Owner.CameraSettings.NearClipDistance;
float zFar = (float)context.Owner.CameraSettings.FarClipDistance;
var ambientLight = frameData.Lights[frameData.LightsInFrustumSorted[0]];
var ambientLightPower = ambientLight.data.Power;
var reflectionTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);
{
context.SetViewport(reflectionTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ScreenSpaceReflection\SSR_fs.sc";
int maxSteps = 50;
switch (Quality.Value)
{
case QualityEnum.Lowest: maxSteps = 15; break;
case QualityEnum.Low: maxSteps = 25; break;
case QualityEnum.Medium: maxSteps = 40; break;
case QualityEnum.High: maxSteps = 60; break;
case QualityEnum.Highest: maxSteps = 100; break;
}
//int maxSteps = 50;
//switch( Quality.Value )
//{
//case QualityEnum.Lowest: maxSteps = 20; break;
//case QualityEnum.Low: maxSteps = 50; break;
//case QualityEnum.Medium: maxSteps = 80; break;
//case QualityEnum.High: maxSteps = 120; break;
//case QualityEnum.Highest: maxSteps = 160; break;
//}
shader.Defines.Add(new CanvasRenderer.ShaderItem.DefineItem("MAX_STEPS", maxSteps.ToString()));
context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer0Texture", out var gBuffer0Texture);
context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out var depthTexture);
context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out var normalTexture);
context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer2Texture", out var gBuffer2Texture);
//!!!!reflection probes?
pipeline.GetBackgroundEnvironmentTextures(context, frameData, /*true, */ out var environmentTexture, out var environmentTextureIBL);
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, depthTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, actualTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2, normalTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
//!!!!rotation, multiplier
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(3, environmentTexture.Value.texture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(4, environmentTextureIBL.Value.texture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(5, Component_RenderingPipeline_Basic.BrdfLUT,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(6, gBuffer2Texture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(7, gBuffer0Texture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
//!!!часть параметров есть UniformsGeneral.sh
shader.Parameters.Set("viewProj", viewProjMatrix);
shader.Parameters.Set("invViewProj", invViewProjMatrix);
shader.Parameters.Set("cameraPosition", cameraPosition);
shader.Parameters.Set("edgeFactorPower", (float)EdgeFactorPower);
shader.Parameters.Set("initialStepScale", (float)InitialStepScale.Value);
shader.Parameters.Set("worldThickness", (float)WorldThickness.Value);
shader.Parameters.Set("colorTextureSize", new Vector4F((float)actualTexture.Result.ResultSize.X, (float)actualTexture.Result.ResultSize.Y, 0.0f, 0.0f));
shader.Parameters.Set("zNear", zNear);
shader.Parameters.Set("zFar", zFar);
shader.Parameters.Set("fov", fov);
shader.Parameters.Set("aspectRatio", aspectRatio);
context.RenderQuadToCurrentViewport(shader);
}
var min = BlurRoughnessMin.Value;
var max = BlurRoughnessMax.Value;
if (min > max)
{
min = max;
}
var blurRoughnessMin = pipeline.GaussianBlur(context, this, reflectionTexture, min, BlurDownscalingMode, BlurDownscalingValue);
var blurRoughnessMax = pipeline.GaussianBlur(context, this, reflectionTexture, max, BlurDownscalingMode, BlurDownscalingValue);
//// Blur Pass:
//var bluredReflection = pipeline.GaussianBlur( context, this, reflectionTexture, BlurFactorOnMaxRoughness, BlurDownscalingMode, BlurDownscalingValue );
// Final Pass:
var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);
{
context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ScreenSpaceReflection\SSR_Apply_fs.sc";
context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer0Texture", out var gBuffer0Texture);
context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out var depthTexture);
context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out var normalTexture);
context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer2Texture", out var gBuffer2Texture);
//!!!!reflection probes?
pipeline.GetBackgroundEnvironmentTextures(context, frameData, /*true, */ out var environmentTexture, out var environmentTextureIBL);
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, actualTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, blurRoughnessMin,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2, blurRoughnessMax,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
//shader.Parameters.Set( "1", new GpuMaterialPass.TextureParameterValue( reflectionTexture,
// TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None ) );
//shader.Parameters.Set( "2", new GpuMaterialPass.TextureParameterValue( bluredReflection,
// TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None ) );
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(3, depthTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(4, normalTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
//!!!!rotation, multiplier
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(5, environmentTexture.Value.texture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(6, environmentTextureIBL.Value.texture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(7, Component_RenderingPipeline_Basic.BrdfLUT,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(8, gBuffer2Texture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(9, gBuffer0Texture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
shader.Parameters.Set("invViewProj", invViewProjMatrix);
shader.Parameters.Set("cameraPosition", cameraPosition);
shader.Parameters.Set("intensity", (float)Intensity);
shader.Parameters.Set("ambientLightPower", ambientLightPower);
context.RenderQuadToCurrentViewport(shader);
}
// Free Targets:
context.DynamicTexture_Free(reflectionTexture);
context.DynamicTexture_Free(blurRoughnessMin);
context.DynamicTexture_Free(blurRoughnessMax);
//context.RenderTarget_Free( bluredReflection );
context.DynamicTexture_Free(actualTexture);
// Update actual Texture:
actualTexture = finalTexture;
//result
sceneTexture = actualTexture;
}
}
//!!!!было. сложно.
//public bool Add( Vec3F p )
//{
// if( radius < 0.0f )
// {
// origin = p;
// radius = 0.0f;
// return true;
// }
// else
// {
// float x = p.x - origin.x;
// float y = p.y - origin.y;
// float z = p.z - origin.z;
// float lengthSqr = x * x + y * y + z * z;
// float r = lengthSqr;
// //float r = ( p - origin ).LengthSqr();
// if( r > radius * radius )
// {
// r = MathEx.Sqrt( r );
// float coef = .5f * ( 1.0f - radius / r );
// origin.x += x * coef;
// origin.y += y * coef;
// origin.z += z * coef;
// //origin += ( p - origin ) * 0.5f * ( 1.0f - radius / r );
// radius += .5f * ( r - radius );
// return true;
// }
// return false;
// }
//}
static void ClosestPtPointTriangle(ref Vector3F p, ref Vector3F a, ref Vector3F b, ref Vector3F c, out Vector3F result)
{
Vector3F ab;
Vector3F.Subtract(ref b, ref a, out ab);
//Vec3 ab = b - a;
Vector3F ac;
Vector3F.Subtract(ref c, ref a, out ac);
//Vec3 ac = c - a;
Vector3F ap;
Vector3F.Subtract(ref p, ref a, out ap);
//Vec3 ap = p - a;
float d1;
Vector3F.Dot(ref ab, ref ap, out d1);
float d2;
Vector3F.Dot(ref ac, ref ap, out d2);
if (d1 <= 0.0f && d2 <= 0.0f)
{
result = a;
return;
}
//check if P in vertex region outside B
Vector3F bp;
Vector3F.Subtract(ref p, ref b, out bp);
//Vec3 bp = p - b;
float d3;
Vector3F.Dot(ref ab, ref bp, out d3);
float d4;
Vector3F.Dot(ref ac, ref bp, out d4);
if (d3 >= 0.0f && d4 <= d3)
{
result = b;
return;
}
float vc = d1 * d4 - d3 * d2;
if (vc <= 0.0f && d1 >= 0.0f && d3 <= 0.0f)
{
float v = d1 / (d1 - d3);
result = a + v * ab;
return;
}
Vector3F cp;
Vector3F.Subtract(ref p, ref c, out cp);
//Vec3 cp = p - c;
float d5; Vector3F.Dot(ref ab, ref cp, out d5);
float d6; Vector3F.Dot(ref ac, ref cp, out d6);
if (d6 >= 0.0f && d5 <= d6)
{
result = c;
return;
}
float vb = d5 * d2 - d1 * d6;
if (vb <= 0.0f && d2 >= 0.0f && d6 <= 0.0f)
{
float w = d2 / (d2 - d6);
result = a + w * ac;
return;
}
float va = d3 * d6 - d5 * d4;
if (va <= 0.0f && (d4 - d3) >= 0.0f && (d5 - d6) >= 0.0f)
{
float w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
result = b + w * (c - b);
return;
}
{
float denom = 1.0f / (va + vb + vc);
float v = vb * denom;
float w = vc * denom;
result = a + ab * v + ac * w;
return;
}
}
public SphereF(SphereF source)
{
Origin = source.Origin;
Radius = source.Radius;
}
void ProcessVertex(ref Vector3F position, out Vector3F result)
{
Matrix4? nullable = new Matrix4?(PosCenter.Value.ToMatrix4());
Matrix4 matrix4 = nullable ?? Matrix4.Identity;
Matrix4F matrix4f = matrix4.ToMatrix4F();
bool inv = matrix4f.Inverse();
MatrixInv = inv;
ResPosVec1 = matrix4f * Pos1n.Value.Position.ToVector3F();
result = position;
var sc = new Vector3F(0.2f, 0.2f, 0.2f);
var rposition = position * sc;
var l_r01 = (float)Pos01n.Value.Scale.X;
var relp01 = (Pos01n.Value.Position).ToVector3F();
var l_dist1 = (rposition - relp01);
float l_l01 = l_dist1.Length();
var l_r02 = (float)Pos02n.Value.Scale.X;
var relp02 = (Pos02n.Value.Position).ToVector3F();
var l_dist2 = (rposition - relp02);
float l_l02 = l_dist2.Length();
var l_r03 = (float)Pos03n.Value.Scale.X;
var relp03 = (Pos03n.Value.Position).ToVector3F();
var l_dist3 = (rposition - relp03);
float l_l03 = l_dist3.Length();
var l_r04 = (float)Pos04n.Value.Scale.X;
var relp04 = (Pos04n.Value.Position).ToVector3F();
var l_dist4 = (rposition - relp04);
float l_l04 = l_dist4.Length();
var f = ((ResPos1.Value.Position - PosCenter.Value.Position) / sc).ToVector3F().GetNormalize();
SphericalDirectionF sd = new SphericalDirectionF(f.X, f.Y);
float ax = MathEx.Acos(f.X);
float ay = MathEx.Asin(f.X);
QuaternionF q = new AnglesF().ToQuaternion();
if (l_l01 <= l_r01)
{
var relp1 = matrix4f * Pos1n.Value.Position.ToVector3F();
result = relp1;
}
if (l_l02 <= l_r02)
{
var relp2 = matrix4f * Pos2n.Value.Position.ToVector3F();;
result = relp2;
}
if (l_l03 <= l_r03)
{
var relp3 = matrix4f * Pos3n.Value.Position.ToVector3F();;
result = relp3;
}
if (l_l04 <= l_r04)
{
var relp4 = matrix4f * Pos4n.Value.Position.ToVector3F();;
result = relp4;
}
}
/// <summary>
/// Rounds a given vector towards zero for each component in it and returns the truncated vector.
/// </summary>
/// <param name="v">The vector to truncate.</param>
/// <returns>The truncated vector</returns>
public Vector3F GetTruncate(Vector3F v)
{
return(new Vector3F((int)v.X, (int)v.Y, (int)v.Z));
}
/// <summary>
/// Rounds the current instance of <see cref="Vector3F"/> towards zero for each component in a vector.
/// </summary>
/// <param name="v"></param>
public void Truncate(Vector3F v)
{
X = (int)X;
Y = (int)Y;
Z = (int)Z;
}
public CapsuleF(Vector3F point1, Vector3F point2, float radius)
{
this.Point1 = point1;
this.Point2 = point2;
this.Radius = radius;
}
public RayF(RayF source)
{
Origin = source.Origin;
Direction = source.Direction;
}
//
static SimpleTypes()
{
//string
RegisterType(typeof(string), delegate(string value)
{
if (value == null)
{
return("");
//throw new Exception( "GetSimpleTypeValue: string type, value = null" );
}
return(value);
}, "");
//bool
RegisterType(typeof(bool), delegate(string value)
{
string lower = value.ToLower();
if (value == "1" || lower == "yes" || lower == "true")
{
return(true);
}
else if (value == "0" || lower == "no" || lower == "false")
{
return(false);
}
else
{
return(bool.Parse(value));
}
}, false);
//sbyte
RegisterType(typeof(sbyte), delegate(string value) { return(sbyte.Parse(value)); }, 0);
//byte
RegisterType(typeof(byte), delegate(string value) { return(byte.Parse(value)); }, 0);
//char
RegisterType(typeof(char), delegate(string value) { return(char.Parse(value)); }, 0);
//short
RegisterType(typeof(short), delegate(string value) { return(short.Parse(value)); }, 0);
//ushort
RegisterType(typeof(ushort), delegate(string value) { return(ushort.Parse(value)); }, 0);
//int
RegisterType(typeof(int), delegate(string value) { return(int.Parse(value)); }, 0);
//uint
RegisterType(typeof(uint), delegate(string value) { return(uint.Parse(value)); }, (uint)0);
//long
RegisterType(typeof(long), delegate(string value) { return(long.Parse(value)); }, (long)0);
//ulong
RegisterType(typeof(ulong), delegate(string value) { return(ulong.Parse(value)); }, (ulong)0);
//float
RegisterType(typeof(float), delegate(string value) { return(float.Parse(value)); }, 0.0f);
//double
RegisterType(typeof(double), delegate(string value) { return(double.Parse(value)); }, 0.0);
//decimal
RegisterType(typeof(decimal), delegate(string value) { return(decimal.Parse(value)); }, (decimal)0.0);
//Vec2
RegisterType(typeof(Vector2F), delegate(string value) { return(Vector2F.Parse(value)); }, Vector2F.Zero);
//Range
RegisterType(typeof(RangeF), delegate(string value) { return(RangeF.Parse(value)); }, RangeF.Zero);
//Vec3
RegisterType(typeof(Vector3F), delegate(string value) { return(Vector3F.Parse(value)); }, Vector3F.Zero);
//Vec4
RegisterType(typeof(Vector4F), delegate(string value) { return(Vector4F.Parse(value)); }, Vector4F.Zero);
//Bounds
RegisterType(typeof(BoundsF), delegate(string value) { return(BoundsF.Parse(value)); }, BoundsF.Zero);
//Quat
RegisterType(typeof(QuaternionF), delegate(string value) { return(QuaternionF.Parse(value)); }, QuaternionF.Identity);
//ColorValue
RegisterType(typeof(ColorValue), delegate(string value) { return(ColorValue.Parse(value)); }, ColorValue.Zero);
//ColorValuePowered
RegisterType(typeof(ColorValuePowered), delegate(string value) { return(ColorValuePowered.Parse(value)); }, ColorValuePowered.Zero);
//ColorPacked
RegisterType(typeof(ColorByte), delegate(string value) { return(ColorByte.Parse(value)); }, ColorByte.Zero);
//SphereDir
RegisterType(typeof(SphericalDirectionF), delegate(string value) { return(SphericalDirectionF.Parse(value)); }, SphericalDirectionF.Zero);
//Vec2I
RegisterType(typeof(Vector2I), delegate(string value) { return(Vector2I.Parse(value)); }, Vector2I.Zero);
//Vec3I
RegisterType(typeof(Vector3I), delegate(string value) { return(Vector3I.Parse(value)); }, Vector3I.Zero);
//Vec4I
RegisterType(typeof(Vector4I), delegate(string value) { return(Vector4I.Parse(value)); }, Vector4I.Zero);
//Rect
RegisterType(typeof(RectangleF), delegate(string value) { return(RectangleF.Parse(value)); }, RectangleF.Zero);
//RectI
RegisterType(typeof(RectangleI), delegate(string value) { return(RectangleI.Parse(value)); }, RectangleI.Zero);
//Degree
RegisterType(typeof(DegreeF), delegate(string value) { return(DegreeF.Parse(value)); }, DegreeF.Zero);
//Radian
RegisterType(typeof(RadianF), delegate(string value) { return(RadianF.Parse(value)); }, RadianF.Zero);
//Vec2D
RegisterType(typeof(Vector2), delegate(string value) { return(Vector2.Parse(value)); }, Vector2.Zero);
//RangeD
RegisterType(typeof(Range), delegate(string value) { return(Range.Parse(value)); }, Range.Zero);
//RangeI
RegisterType(typeof(RangeI), delegate(string value) { return(RangeI.Parse(value)); }, RangeI.Zero);
//Vec3D
RegisterType(typeof(Vector3), delegate(string value) { return(Vector3.Parse(value)); }, Vector3.Zero);
//Vec4D
RegisterType(typeof(Vector4), delegate(string value) { return(Vector4.Parse(value)); }, Vector4.Zero);
//BoundsD
RegisterType(typeof(Bounds), delegate(string value) { return(Bounds.Parse(value)); }, Bounds.Zero);
//QuatD
RegisterType(typeof(Quaternion), delegate(string value) { return(Quaternion.Parse(value)); }, Quaternion.Identity);
//SphereDirD
RegisterType(typeof(SphericalDirection), delegate(string value) { return(SphericalDirection.Parse(value)); }, SphericalDirection.Zero);
//RectD
RegisterType(typeof(Rectangle), delegate(string value) { return(Rectangle.Parse(value)); }, Rectangle.Zero);
//DegreeD
RegisterType(typeof(Degree), delegate(string value) { return(Degree.Parse(value)); }, Degree.Zero);
//RadianD
RegisterType(typeof(Radian), delegate(string value) { return(Radian.Parse(value)); }, Radian.Zero);
//Angles
RegisterType(typeof(AnglesF), delegate(string value) { return(AnglesF.Parse(value)); }, AnglesF.Zero);
//AnglesD
RegisterType(typeof(Angles), delegate(string value) { return(Angles.Parse(value)); }, Angles.Zero);
//Mat2F
RegisterType(typeof(Matrix2F), delegate(string value) { return(Matrix2F.Parse(value)); }, Matrix2F.Zero);
//Mat2D
RegisterType(typeof(Matrix2), delegate(string value) { return(Matrix2.Parse(value)); }, Matrix2.Zero);
//Mat3F
RegisterType(typeof(Matrix3F), delegate(string value) { return(Matrix3F.Parse(value)); }, Matrix3F.Zero);
//Mat3D
RegisterType(typeof(Matrix3), delegate(string value) { return(Matrix3.Parse(value)); }, Matrix3.Zero);
//Mat4F
RegisterType(typeof(Matrix4F), delegate(string value) { return(Matrix4F.Parse(value)); }, Matrix4F.Zero);
//Mat4D
RegisterType(typeof(Matrix4), delegate(string value) { return(Matrix4.Parse(value)); }, Matrix4.Zero);
//PlaneF
RegisterType(typeof(PlaneF), delegate(string value) { return(PlaneF.Parse(value)); }, PlaneF.Zero);
//PlaneD
RegisterType(typeof(Plane), delegate(string value) { return(Plane.Parse(value)); }, Plane.Zero);
//Transform
RegisterType(typeof(Transform), delegate(string value) { return(Transform.Parse(value)); }, Transform.Identity);
//UIMeasureValueDouble
RegisterType(typeof(UIMeasureValueDouble), delegate(string value) { return(UIMeasureValueDouble.Parse(value)); }, new UIMeasureValueDouble());
//UIMeasureValueVec2
RegisterType(typeof(UIMeasureValueVector2), delegate(string value) { return(UIMeasureValueVector2.Parse(value)); }, new UIMeasureValueVector2());
//UIMeasureValueRect
RegisterType(typeof(UIMeasureValueRectangle), delegate(string value) { return(UIMeasureValueRectangle.Parse(value)); }, new UIMeasureValueRectangle());
RegisterType(typeof(RangeVector3F), delegate(string value) { return(RangeVector3F.Parse(value)); }, RangeVector3F.Zero);
RegisterType(typeof(RangeColorValue), delegate(string value) { return(RangeColorValue.Parse(value)); }, RangeColorValue.Zero);
//no Parse methods. This is complex structures. This is not simple types? or just can't parse?
//Box
//Capsule
//Cone
//Line3
//Line2
//Ray
//Frustum?
RegisterConvertDoubleToFloatTypes();
}
public RayF(Vector3F origin, Vector3F direction)
{
this.Origin = origin;
this.Direction = direction;
}
public static object ExtractOneComponentArray(StandardVertex[] vertices, Components component)
{
switch (component)
{
case Components.Position:
{
Vector3F[] array = new Vector3F[vertices.Length];
for (int n = 0; n < vertices.Length; n++)
{
array[n] = vertices[n].Position;
}
return(array);
}
case Components.Normal:
{
Vector3F[] array = new Vector3F[vertices.Length];
for (int n = 0; n < vertices.Length; n++)
{
array[n] = vertices[n].Normal;
}
return(array);
}
case Components.Tangent:
{
Vector4F[] array = new Vector4F[vertices.Length];
for (int n = 0; n < vertices.Length; n++)
{
array[n] = vertices[n].Tangent;
}
return(array);
}
case Components.Color:
{
ColorValue[] array = new ColorValue[vertices.Length];
for (int n = 0; n < vertices.Length; n++)
{
array[n] = vertices[n].Color;
}
return(array);
}
case Components.TexCoord0:
{
Vector2F[] array = new Vector2F[vertices.Length];
for (int n = 0; n < vertices.Length; n++)
{
array[n] = vertices[n].TexCoord0;
}
return(array);
}
case Components.TexCoord1:
{
Vector2F[] array = new Vector2F[vertices.Length];
for (int n = 0; n < vertices.Length; n++)
{
array[n] = vertices[n].TexCoord1;
}
return(array);
}
case Components.TexCoord2:
{
Vector2F[] array = new Vector2F[vertices.Length];
for (int n = 0; n < vertices.Length; n++)
{
array[n] = vertices[n].TexCoord2;
}
return(array);
}
case Components.TexCoord3:
{
Vector2F[] array = new Vector2F[vertices.Length];
for (int n = 0; n < vertices.Length; n++)
{
array[n] = vertices[n].TexCoord3;
}
return(array);
}
case Components.BlendIndices:
{
Vector4I[] array = new Vector4I[vertices.Length];
for (int n = 0; n < vertices.Length; n++)
{
array[n] = vertices[n].BlendIndices;
}
return(array);
}
case Components.BlendWeights:
{
Vector4F[] array = new Vector4F[vertices.Length];
for (int n = 0; n < vertices.Length; n++)
{
array[n] = vertices[n].BlendWeights;
}
return(array);
}
}
Log.Fatal("StandardVertex: ExtractOneComponentArray: Invalid requested component.");
return(null);
}
public void GetPointOnRay(float t, out Vector3F result)
{
result.X = Origin.X + Direction.X * t;
result.Y = Origin.Y + Direction.Y * t;
result.Z = Origin.Z + Direction.Z * t;
}
public RangeVector3F(RangeVector3F a)
{
Minimum = a.Minimum;
Maximum = a.Maximum;
}
public static BulletSharp.Math.Vector3 Convert(Vector3F v)
{
return(new BulletSharp.Math.Vector3(v.X, v.Y, v.Z));
}
//
public KeyFrame(float time, int boneIndex, Vector3F position, QuaternionF rotation, Vector3F scale)
{
this.Time = time;
this.BoneIndex = boneIndex;
this.Position = position;
this.Rotation = rotation;
this.Scale = scale;
}
public static void Convert(ref Vector3F v, out BulletSharp.Math.Vector3 result)
{
result = new BulletSharp.Math.Vector3(v.X, v.Y, v.Z);
}
/////////////////////////////////////////
void ProcessVertex(float multiplier, float multiplier1, float invMultiplier, ref Vector3F position, out Vector3F result)
{
var random = new Random(position.GetHashCode());
float nposx = 0;
float Ax = 0;
float nposy = 0;
float Ay = 0;
float nposz = 0;
float Az = 0;
float ofs1 = off1;
float ofs2 = off2;
result = position;
if (posN == 1)
{
if (sigN == 1 && position.X <= (float)Multiplier2)
{
Ax = multiplier * (float)Math.Exp(-position.Z * position.Z * multiplier1);
nposx = position.X + Math.Sign(position.X) * (Ax * ((float)Math.Exp(-position.Y * position.Y * multiplier1)));
if (nposx > (float)Multiplier2)
{
nposx = (float)Multiplier2;
}
result = new Vector3F(
nposx,
position.Y,
position.Z);
}
if (sigN == -1 && position.X > (float)Multiplier2)
{
Ax = multiplier * (float)Math.Exp(-position.Z * position.Z * multiplier1);
nposx = position.X + Math.Sign(position.X) * (Ax * ((float)Math.Exp(-position.Y * position.Y * multiplier1)));
if (nposx < (float)Multiplier2)
{
nposx = (float)Multiplier2;
}
result = new Vector3F(
nposx,
position.Y,
position.Z);
}
}
else if (posN == 2)
{
if (sigN == 1 && position.Y <= (float)Multiplier2)
{
Ay = multiplier * (float)Math.Exp(-position.Z * position.Z * multiplier1);
nposy = position.Y + Math.Sign(position.Y) * (Ay * ((float)Math.Exp(-position.X * position.X * multiplier1)));
if (nposy > (float)Multiplier2)
{
nposy = (float)Multiplier2;
}
result = new Vector3F(
position.X,
nposy,
position.Z);
}
if (sigN == -1 && position.Y > (float)Multiplier2)
{
Ay = multiplier * (float)Math.Exp(-position.Z * position.Z * multiplier1);
nposy = position.Y + Math.Sign(position.Y) * (Ay * ((float)Math.Exp(-position.X * position.X * multiplier1)));
if (nposy < (float)Multiplier2)
{
nposy = (float)Multiplier2;
}
result = new Vector3F(
position.X,
nposy,
position.Z);
}
}
else if (posN == 3)
{
if (sigN == 1 && position.Z <= (float)Multiplier2)
{
Az = multiplier * (float)Math.Exp(-(position.X - ofs2) * (position.X - ofs2) * multiplier1);
nposz = position.Z + Math.Sign(position.Z) * (Az * ((float)Math.Exp(-(position.Y - ofs1) * (position.Y - ofs1) * multiplier1)));
if (nposz > (float)Multiplier2)
{
nposz = (float)Multiplier2;
}
result = new Vector3F(
position.X,
position.Y,
nposz);
}
if (sigN == -1 && position.Z > (float)Multiplier2)
{
Az = multiplier * (float)Math.Exp(-(position.X - ofs2) * (position.X - ofs2) * multiplier1);
nposz = position.Z + Math.Sign(position.Z) * (Az * ((float)Math.Exp(-(position.Y - ofs1) * (position.Y - ofs1) * multiplier1)));
if (nposz < (float)Multiplier2)
{
nposz = (float)Multiplier2;
}
result = new Vector3F(
position.X,
position.Y,
nposz);
}
}
}
public void GetDirection(out Vector3F result)
{
Vector3F.Subtract(ref Point2, ref Point1, out result);
result.Normalize();
}
public EnvironmentTextureData(Component_Image texture)
{
this.texture = texture;
this.rotation = Matrix3F.Identity;
this.multiplier = Vector3F.One;
}
public CapsuleF(CapsuleF source)
{
Point1 = source.Point1;
Point2 = source.Point2;
Radius = source.Radius;
}
/// <summary>
/// Constructs a cone with the given origin, axis and angle.
/// </summary>
/// <param name="origin">The origin.</param>
/// <param name="axis">The axis.</param>
/// <param name="angle">The angle.</param>
public ConeF(Vector3F origin, Vector3F axis, RadianF angle)
{
this.Origin = origin;
this.Axis = axis;
this.Angle = angle;
}
/// <summary>
/// Calculates the distance between two vectors.
/// </summary>
/// <param name="v1">The first vector.</param>
/// <param name="v2">The second vector.</param>
/// <returns>The distance between two vectors.</returns>
public static float Distance(ref Vector3F v1, ref Vector3F v2)
{
Subtract(ref v1, ref v2, out Vector3F result);
return(result.Length());
}
