public void TestF4Div(float a, float b, float c)
{
_float4 _f1 = new _float4(a, b, c, 0.0f);
float4 f1 = new float4(a, b, c, 0.0f);
_float4 _f2 = new _float4(a, b, c, 0.0f);
float4 f2 = new float4(a, b, c, 0.0f);
_float4 _f3 = _f1 + _f2;
float4 f3 = f1 + f2;
Assert.AreEqual(f3.x, _f3.x);
Assert.AreEqual(f3.y, _f3.y);
Assert.AreEqual(f3.z, _f3.z);
Assert.AreEqual(f3.w, _f3.w);
}
public static void shadernode_set_attribute_vec(uint clientId, uint shaderId, uint shadernodeId, [MarshalAs(UnmanagedType.LPStr)] string name, float4 val)
{
cycles_shadernode_set_attribute_vec(clientId, shaderId, shadernodeId, name, val.x, val.y, val.z);
}
public unsafe void TestInitFloat4_Float4(float a, float b, float c, float d)
{
float4 f4 = new float4(a, b, c, d);
_float4 _f4 = new _float4(a, b, c, d);
byte* addr = (byte*)&_f4;
Console.WriteLine("Size: {0}", sizeof(_float4));
Console.WriteLine("x Offset: {0}", (byte*)&_f4.x - addr);
Console.WriteLine("y Offset: {0}", (byte*)&_f4.y - addr);
Console.WriteLine("z Offset: {0}", (byte*)&_f4.z - addr);
Console.WriteLine("w Offset: {0}", (byte*)&_f4.w - addr);
Console.WriteLine("morjeeens");
Assert.AreEqual(f4.x, _f4.x);
Assert.AreEqual(f4.y, _f4.y);
Assert.AreEqual(f4.z, _f4.z);
Assert.AreEqual(f4.w, _f4.w);
}
public float TestInitFloat4GetZ(float a, float b, float c)
{
float4 f4 = new float4(a, b, c);
return f4.z;
}
public override Shader GetShader()
{
if (!string.IsNullOrEmpty(m_original_background.Xml))
{
var xml = m_original_background.Xml;
Shader.ShaderFromXml(ref m_shader, xml);
}
else
{
var black = new float4(0.0f);
var tst = new float4(1.0f, 0.5f, 0.25f);
var color1 = (m_original_background.color1.IsEmpty ? tst : RenderEngine.CreateFloat4(m_original_background.color1)) ^ m_original_background.Gamma;
var color2 = (m_original_background.color2.IsEmpty ? tst : RenderEngine.CreateFloat4(m_original_background.color2)) ^ m_original_background.Gamma;
var bgcolor = (m_original_background.bg_color.IsEmpty ? black : RenderEngine.CreateFloat4(m_original_background.bg_color)) ^ m_original_background.Gamma;
var skycolor = (m_original_background.sky_color.IsEmpty ? black : RenderEngine.CreateFloat4(m_original_background.sky_color)) ^ m_original_background.Gamma;
var reflcolor = (m_original_background.refl_color.IsEmpty ? black : RenderEngine.CreateFloat4(m_original_background.refl_color)) ^ m_original_background.Gamma;
// our main background shader. With just this, and some color != black set we should get skylighting
// use the bgcolor from the background (360deg) environment if it is specified, instead.
_backgroundNode.ins.Strength.Value = 1.0f;
_backgroundNode.ins.Color.Value = (m_original_background.background_environment != null ? bgcolor : color1);
#region skylight disabler/enabler nodes
// node to give highest value (used for light path checks)
_max.ins.Value1.Value = 0.0f;
_max.ins.Value2.Value = 0.0f;
#endregion
#region gradient bg nodes
// just simple linear gradient
_colorramp.ColorBand.Interpolation = ColorBand.Interpolations.Linear;
// bottom color on 0.0f
_colorramp.ColorBand.InsertColorStop(color2, 0.0f);
// top color on 1.0f
_colorramp.ColorBand.InsertColorStop(color1, 1.0f);
#endregion
#region nodes for environment textures on bg/refl/skylight
if (m_original_background.wallpaper.HasTextureImage && m_original_background.background_fill == BackgroundStyle.WallpaperImage)
{
RenderEngine.SetTextureImage(_bgEnvTexture, m_original_background.wallpaper);
}
else if (m_original_background.bg.HasTextureImage)
{
RenderEngine.SetTextureImage(_bgEnvTexture, m_original_background.bg);
}
if (m_original_background.refl.HasTextureImage)
{
RenderEngine.SetTextureImage(_reflEnvTexture, m_original_background.refl);
}
if (m_original_background.sky.HasTextureImage)
{
RenderEngine.SetTextureImage(_skyEnvTexture, m_original_background.sky);
}
_skyBg.ins.Color.Value = skycolor;
_skyBg.ins.Strength.Value = 1.0f;
_reflBg.ins.Color.Value = reflcolor;
_reflBg.ins.Strength.Value = 1.0f;
#endregion
// add background nodes
m_shader.AddNode(_backgroundNode);
m_shader.AddNode(_reflBg);
m_shader.AddNode(_skyBg);
// add environment texture nodes
m_shader.AddNode(_bgEnvTexture);
m_shader.AddNode(_reflEnvTexture);
m_shader.AddNode(_skyEnvTexture);
// light paths
m_shader.AddNode(_lightpath);
// a max for skylight stuff
m_shader.AddNode(_max);
// two mixer nodes
m_shader.AddNode(_mixBgAndRefl);
m_shader.AddNode(_mixSkylightSwitch);
// gradient bg nodes
m_shader.AddNode(_textureCoordinates);
m_shader.AddNode(_mapping);
m_shader.AddNode(_gradient);
m_shader.AddNode(_colorramp);
// to control skylight influence, the trick is to only sample on camera ray and on
// glossy rays. This way we can see the background in
// reflections and when we're looking directly to it.
// our max(v1,v2) will be 1.0 when either or both are set
_lightpath.outs.IsCameraRay.Connect(_max.ins.Value1);
_lightpath.outs.IsGlossyRay.Connect(_max.ins.Value2);
// also connect glossy ray to mix_bg_refl, so we get refl_bg when glossy ray
_lightpath.outs.IsGlossyRay.Connect(_mixBgAndRefl.ins.Fac);
_max.outs.Value.Connect(_mixSkylightSwitch.ins.Fac);
// if there is a bg texture, put that in bg color
if (m_original_background.bg.HasTextureImage && m_original_background.background_fill == BackgroundStyle.Environment && !m_original_background.PlanarProjection)
{
_bgEnvTexture.outs.Color.Connect(_backgroundNode.ins.Color);
}
// or if gradient fill is needed, so lets do that.
else if (m_original_background.background_fill == BackgroundStyle.Gradient)
{
// gradient is 'screen-based', so use window tex coordinates
_textureCoordinates.outs.Window.Connect(_mapping.ins.Vector);
// rotate those coords into gradient
_mapping.outs.Vector.Connect(_gradient.ins.Vector);
// and finally into our color ramp
_gradient.outs.Fac.Connect(_colorramp.ins.Fac);
// now use that as background input
_colorramp.outs.Color.Connect(_backgroundNode.ins.Color);
}
else if(m_original_background.PlanarProjection)
{
_mapping.outs.Vector.Connect(_bgEnvTexture.ins.Vector);
_bgEnvTexture.outs.Color.Connect(_backgroundNode.ins.Color);
_bgEnvTexture.Projection = TextureNode.EnvironmentProjection.Wallpaper;
}
else if (m_original_background.background_fill == BackgroundStyle.WallpaperImage)
{
_bgEnvTexture.outs.Color.Connect(_backgroundNode.ins.Color);
_bgEnvTexture.Projection = TextureNode.EnvironmentProjection.Wallpaper;
}
// connect refl env texture if texture exists
if (m_original_background.refl.HasTextureImage)
{
_reflEnvTexture.outs.Color.Connect(_reflBg.ins.Color);
}
// connect sky env texture if texture exists
if (m_original_background.sky.HasTextureImage)
{
_skyEnvTexture.outs.Color.Connect(_skyBg.ins.Color);
}
if (m_original_background.HasSky && m_original_background.skylight_enabled)
{
_skyBg.outs.Background.Connect(_mixSkylightSwitch.ins.Closure1);
}
else
{
if (m_original_background.skylight_enabled)
{
_mixBgAndRefl.outs.Closure.Connect(_mixSkylightSwitch.ins.Closure1);
}
}
// background always goes into closure 1 for bg+refl mix
_backgroundNode.outs.Background.Connect(_mixBgAndRefl.ins.Closure1);
// if we have a reflection color or texture, use that in
// background and reflection mixer.
if (m_original_background.HasRefl)
{
_reflBg.outs.Background.Connect(_mixBgAndRefl.ins.Closure2);
}
else // no color or texture for reflections, use regular background
{
_backgroundNode.outs.Background.Connect(_mixBgAndRefl.ins.Closure2);
}
// the bakground and reflection should always be connected to skylight
// switch in second closure slot. This is so that direct background ray
// hit from camera shows background. Also glossy ray still should be evaluated
// to this one.
_mixBgAndRefl.outs.Closure.Connect(_mixSkylightSwitch.ins.Closure2);
_mixSkylightSwitch.outs.Closure.Connect(m_shader.Output.ins.Surface);
}
// phew, done.
m_shader.FinalizeGraph();
m_shader.Tag();
return m_shader;
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="old">float4 to copy</param>
public float4(float4 old)
: this(old.x, old.y, old.z, old.w)
{
}
public static float Dot(float4 a, float4 b)
{
return (a.x * b.x + a.y * b.y) + (a.z * b.z + a.w * b.w);
}
public void SetTranslate(float4 t)
{
x.w = t.x;
y.w = t.y;
z.w = t.z;
}
/// <summary>
/// Compute a transform given the position, point to look at and
/// an up vector.
/// </summary>
/// <param name="pos"></param>
/// <param name="look"></param>
/// <param name="up"></param>
/// <returns></returns>
public static Transform LookAt(float4 pos, float4 look, float4 up)
{
return (Transform)(_Transform.LookAt((_float4)pos, (_float4)look, (_float4)up));
}
/// <summary>
/// Get a float4 from given string. This function creates a new float4
/// </summary>
/// <param name="f4">Will be assigned a new float4 when at least 3 floats are found</param>
/// <param name="floats">String with 3 or more floats. At most 4 will be used</param>
/// <returns>true if a parsing was possible</returns>
public bool get_float4(float4 f4, string floats)
{
//f4 = new float4(0.0f);
if (string.IsNullOrEmpty(floats)) return false;
var vec = parse_floats(floats);
if (vec.Length < 3) return false;
f4.x = vec[0];
f4.y = vec[1];
f4.z = vec[2];
if (vec.Length >= 4)
f4.w = vec[3];
return true;
}
public float4 this[int index]
{
get
{
switch (index)
{
case 0:
return x;
case 1:
return y;
case 2:
return z;
case 3:
return w;
default:
throw new IndexOutOfRangeException("Only 0-3 are acceptable");
}
}
set
{
switch (index)
{
case 0:
x = value;
break;
case 1:
y = value;
break;
case 2:
z = value;
break;
case 3:
w = value;
break;
default:
throw new IndexOutOfRangeException("Only 0-3 are acceptable");
}
}
}
public static void shadernode_set_attribute_vec(uint clientId, uint shaderId, uint shadernodeId, [MarshalAs(UnmanagedType.LPStr)] string name, float4 val)
{
cycles_shadernode_set_attribute_vec(clientId, shaderId, shadernodeId, name, val.x, val.y, val.z);
}
/// <summary>
/// Read a transform from XML.
///
/// If all are available then they are read and applied to transform according formula:
///
/// transform = ((matrix * translate) * rotate) * scale
/// </summary>
/// <param name="node"></param>
/// <param name="transform"></param>
private void ReadTransform(System.Xml.XmlReader node, ref Transform transform)
{
var mat = node.GetAttribute("matrix");
var f4 = new float4(0.0f);
var t = new Transform();
if (Utilities.Instance.get_transform(t, mat)) transform = t;
var trans = node.GetAttribute("translate");
if (Utilities.Instance.get_float4(f4, trans)) transform = transform*Transform.Translate(f4);
var rotate = node.GetAttribute("rotate");
if (Utilities.Instance.get_float4(f4, rotate))
{
var a = DegToRad(f4[0]);
var axis = new float4(f4[1], f4[2], f4[3]);
transform = transform*ccl.Transform.Rotate(a, axis);
}
var scale = node.GetAttribute("scale");
if (!string.IsNullOrEmpty(scale))
{
var components = Utilities.Instance.parse_floats(scale);
if(components.Length == 3)
{
transform = transform*ccl.Transform.Scale(components[0], components[1], components[2]);
}
}
}
/// <summary>
/// Rotation matrix for given angle (radians) around the given rotation axis
/// </summary>
/// <param name="angle">Angle in radians</param>
/// <param name="rotation_axis">axis around which the rotation is. w of float4 is unused</param>
/// <returns></returns>
public static Transform Rotate(float angle, float4 rotation_axis)
{
var axis = new float4(rotation_axis) { w = 0.0f };
var s = (float)Math.Sin(angle);
var c = (float)Math.Cos(angle);
var t = 1.0f - c;
axis = float4.Normalize(axis);
return new Transform(
axis.x * axis.x * t + c,
axis.x * axis.y * t - s * axis.z,
axis.x * axis.z * t + s * axis.y,
0.0f,
axis.y * axis.x * t + s * axis.z,
axis.y * axis.y * t + c,
axis.y * axis.z * t - s * axis.x,
0.0f,
axis.z * axis.x * t - s * axis.y,
axis.z * axis.y * t + s * axis.x,
axis.z * axis.z * t + c,
0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
}
public static float4 Normalize(float4 a)
{
return a / a.Length();
}
/// <summary>
/// Give translation matrix for vector t
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public static Transform Translate(float4 t)
{
return new Transform(
1, 0, 0, t.x,
0, 1, 0, t.y,
0, 0, 1, t.z,
0, 0, 0, 1);
}
/// <summary>
/// Copy values from given source float4
/// </summary>
/// <param name="source">float4 to copy from</param>
public void Copy(float4 source)
{
x = source.x;
y = source.y;
z = source.z;
w = source.w;
}
/// <summary>
/// Create a new transform using the given
/// floats
/// </summary>
/// <param name="a">M00</param>
/// <param name="b">M01</param>
/// <param name="c">M02</param>
/// <param name="d">M03</param>
/// <param name="e">M10</param>
/// <param name="f">M11</param>
/// <param name="g">M12</param>
/// <param name="h">M13</param>
/// <param name="i">M20</param>
/// <param name="j">M21</param>
/// <param name="k">M22</param>
/// <param name="l">M23</param>
/// <param name="m">M30</param>
/// <param name="n">M31</param>
/// <param name="o">M32</param>
/// <param name="p">M33</param>
public Transform(
float a, float b, float c, float d,
float e, float f, float g, float h,
float i, float j, float k, float l,
float m, float n, float o, float p
)
{
x = new float4(a, b, c, d);
y = new float4(e, f, g, h);
z = new float4(i, j, k, l);
w = new float4(m, n, o, p);
}
/// <summary>
/// Convert a Rhino light into a <c>CyclesLight</c>.
/// </summary>
/// <param name="lg">The Rhino light to convert</param>
/// <param name="gamma"></param>
/// <returns><c>CyclesLight</c></returns>
internal CyclesLight ConvertLight(Rhino.Geometry.Light lg, float gamma)
{
var enabled = lg.IsEnabled ? 1.0 : 0.0;
var spotangle = 0.0;
var smooth = 0.0;
var size = 0.0f;
var strength = (float)(lg.Intensity * _engineSettings.PointlightFactor * enabled);
var axisu = new float4(0.0f);
var axisv = new float4(0.0f);
var useMis = false;
var sizeU = 0.0f;
var sizeV = 0.0f;
var co = RenderEngine.CreateFloat4(lg.Location.X, lg.Location.Y, lg.Location.Z);
var dir = RenderEngine.CreateFloat4(lg.Direction.X, lg.Direction.Y, lg.Direction.Z);
var color = RenderEngine.CreateFloat4(lg.Diffuse.R, lg.Diffuse.G, lg.Diffuse.B, lg.Diffuse.A);
var lt = LightType.Point;
if (lg.IsDirectionalLight)
{
lt = LightType.Distant;
strength = (float)(lg.Intensity * _engineSettings.SunlightFactor * enabled);
//size = 0.01f;
}
else if (lg.IsSpotLight)
{
lt = LightType.Spot;
spotangle = lg.SpotAngleRadians * 2;
smooth = 1.0 / Math.Max(lg.HotSpot, 0.001f) - 1.0;
strength = (float)(lg.Intensity * _engineSettings.SpotlightFactor * enabled);
}
else if (lg.IsRectangularLight)
{
lt = LightType.Area;
strength = (float)(lg.Intensity * _engineSettings.ArealightFactor * enabled);
var width = lg.Width;
var length = lg.Length;
sizeU = (float)width.Length;
sizeV = (float)length.Length;
size = 1.0f;
var rectLoc = lg.Location + (lg.Width * 0.5) + (lg.Length * 0.5);
co = RenderEngine.CreateFloat4(rectLoc.X, rectLoc.Y, rectLoc.Z);
width.Unitize();
length.Unitize();
axisu = RenderEngine.CreateFloat4(width.X, width.Y, width.Z);
axisv = RenderEngine.CreateFloat4(length.X, length.Y, length.Z);
useMis = true;
}
else if (lg.IsLinearLight)
{
throw new Exception("Linear light handled in wrong place. Contact developer [email protected]");
}
var clight = new CyclesLight
{
Type = lt,
Co = co,
Dir = dir,
DiffuseColor = color,
Size = size,
SizeU = sizeU,
SizeV = sizeV,
AxisU = axisu,
AxisV = axisv,
UseMis = useMis,
SpotAngle = (float)spotangle,
SpotSmooth = (float)smooth,
Strength = strength,
CastShadow = true,
Gamma = gamma,
Id = lg.Id
};
return clight;
}
