C# IColorType类代码示例

 internal HistoryData(int Capacity, IColorType Color)
 {
 	m_Color = Color.GetAsRGBA_Bytes();
     m_Capacity = Capacity;
     m_Data = new TwoSidedStack<double>();
     Reset();
 }

			internal HistoryData(int capacity, IColorType lineColor)
			{
				this.lineColor = lineColor.GetAsRGBA_Bytes();
				this.capacity = capacity;
				data = new List<double>();
				Reset();
			}

 public override void EvaluateShadow(ShadePointInfo pt, float u0, float u1, float u2, out IColorType radiance, out float pdf, out RayData ray)
 {
     var wi = MC.CosineSampleHemisphere(u1, u2);
     pdf = wi.z * MathLab.INVPI;
     wi = pt.Frame.ToWorld(ref wi);
     ray = new RayData(ref pt.HitPoint, ref wi, 1e-4f, float.MaxValue);
     radiance = Le(ref wi);
 }

        public override void F(ShadePointInfo pt, out IColorType fs, BrdfType types = BrdfType.Diffuse)
        {
            float c = 1f - Vector.Dot(ref pt.IncomingDirection, ref pt.ShadingNormal);
            float Re = R0 + (1f - R0) * c * c * c * c * c;

            float P = .25f + .5f * Re;

            fs = pt.Diffuse.CloneValue().Mul(MathLab.INVPI).Mul((1f - Re) / (1f - P));
        }

        public override void EvaluateIllumination(RayEngineScene scn, float u0, float u1, float u2, float u3, float u4, out RayData ray, out float pdf, out IColorType radiance)
        {
            Vector dir = MC.UniformSampleSphere(u0, u1);

            ray = new RayData(ref Position, ref dir, 1e-4f, 1e4f);

            pdf = MathLab.INV4PI;

            radiance = (power.Mul(MathLab.M_PI * 4f));
        }

 public override void EvaluateShadow(ShadePointInfo pt, float u0, float u1, float u2, out IColorType radiance, out float pdf, out RayData ray)
 {
     var dir = -(Position - pt.HitPoint);
     var l2 = dir.Length2();
     var l = MathLab.Sqrt(l2);
     dir.Normalize();
     pdf = MC.UniformSpherePdf();
     ray = new RayData(ref pt.HitPoint, ref dir, 1e-4f, l - 1e-4f);
     radiance = power.Mul(1f / l);
     //float theta = Vector.SphericalTheta(ref dir);
     //Profile.Evaluate(Vector.SphericalPhi(ref dir) * MathLab.INVTWOPI, theta * MathLab.INVPI);
 }

		public override void Render(IVertexSource vertexSource, int pathIndexToRender, IColorType colorBytes)
		{
			rasterizer.reset();
			Affine transform = GetTransform();
			if (!transform.is_identity())
			{
				vertexSource = new VertexSourceApplyTransform(vertexSource, transform);
			}
			rasterizer.add_path(vertexSource, pathIndexToRender);
			if (destImageByte != null)
			{
				scanlineRenderer.RenderSolid(destImageByte, rasterizer, m_ScanlineCache, colorBytes.GetAsRGBA_Bytes());
				DestImage.MarkImageChanged();
			}
			else
			{
				scanlineRenderer.RenderSolid(destImageFloat, rasterizer, m_ScanlineCache, colorBytes.GetAsRGBA_Floats());
				destImageFloat.MarkImageChanged();
			}
		}

		public abstract void FillRectangle(double left, double bottom, double right, double top, IColorType fillColor);

		public void Render(IVertexSource vertexSource, Vector2 position, IColorType color)
		{
			Render(new VertexSourceApplyTransform(vertexSource, Affine.NewTranslation(position.x, position.y)), 0, color);
		}

		public abstract void Clear(IColorType color);

		public override void FillRectangle(double left, double bottom, double right, double top, IColorType fillColor)
		{
			RoundedRect rect = new RoundedRect(left, bottom, right, top, 0);
			Render(rect, fillColor.GetAsRGBA_Bytes());
		}

 public void ActiveColor(IColorType c)
 {
     m_active_color = c.GetAsRGBA_Doubles();
 }

 public void BackgroundColor(IColorType bk)
 {
     unsafe { m_pixf.MakePixel(m_pBackBufferColor, bk); }
 }

 //--------------------------------------------------------------------
 public void Clear(IColorType in_c)
 {
     uint y;
     RGBA_Bytes c = new RGBA_Bytes(in_c.R_Byte, in_c.G_Byte, in_c.B_Byte, in_c.A_Byte);
     if (Width != 0)
     {
         for (y = 0; y < Height; y++)
         {
             base.CopyHorizontalLine(0, (int)y, Width, c);
         }
     }
 }

 public span_image_filter_rgba_bilinear_clip(IImageBufferAccessor src,
     IColorType back_color, ISpanInterpolator inter)
     : base(src, inter, null)
 {
     m_OutsideSourceColor = back_color.GetAsRGBA_Bytes();
 }