internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
{
// If we're told we can skip the channel check, then we must be on channel
Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));
if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
{
checked
{
Transform vTransform = Transform;
// Obtain handles for properties that implement DUCE.IResource
DUCE.ResourceHandle hTransform;
if (vTransform == null ||
Object.ReferenceEquals(vTransform, Transform.Identity)
)
{
hTransform = DUCE.ResourceHandle.Null;
}
else
{
hTransform = ((DUCE.IResource)vTransform).GetHandle(channel);
}
DUCE.MILCMD_PATHGEOMETRY data;
data.Type = MILCMD.MilCmdPathGeometry;
data.Handle = _duceResource.GetHandle(channel);
data.hTransform = hTransform;
data.FillRule = FillRule;
byte[] pathDataToMarshal = _data == null?
Geometry.GetEmptyPathGeometryData().SerializedData:
_data;
unsafe
{
fixed(byte *pbPathData = pathDataToMarshal)
{
data.FiguresSize = (uint)GetFigureSize(pbPathData);
channel.BeginCommand(
(byte *)&data,
sizeof(DUCE.MILCMD_PATHGEOMETRY),
(int)data.FiguresSize
);
channel.AppendCommandData(pbPathData, (int)data.FiguresSize);
}
channel.EndCommand();
}
}
}
base.UpdateResource(channel, skipOnChannelCheck);
}
private void ManualUpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
{
// If we're told we can skip the channel check, then we must be on channel
Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));
if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
{
checked
{
Transform vTransform = Transform;
// Obtain handles for properties that implement DUCE.IResource
DUCE.ResourceHandle hTransform;
if (vTransform == null ||
Object.ReferenceEquals(vTransform, Transform.Identity)
)
{
hTransform = DUCE.ResourceHandle.Null;
}
else
{
hTransform = ((DUCE.IResource)vTransform).GetHandle(channel);
}
DUCE.MILCMD_PATHGEOMETRY data;
data.Type = MILCMD.MilCmdPathGeometry;
data.Handle = _duceResource.GetHandle(channel);
data.hTransform = hTransform;
data.FillRule = FillRule;
PathGeometryData pathData = GetPathGeometryData();
data.FiguresSize = pathData.Size;
unsafe
{
channel.BeginCommand(
(byte *)&data,
sizeof(DUCE.MILCMD_PATHGEOMETRY),
(int)data.FiguresSize
);
fixed(byte *pPathData = pathData.SerializedData)
{
channel.AppendCommandData(pPathData, (int)data.FiguresSize);
}
}
channel.EndCommand();
}
}
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
{
// If we're told we can skip the channel check, then we must be on channel
Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));
if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
{
base.UpdateResource(channel, skipOnChannelCheck);
// Read values of properties into local variables
DoubleCollection vDashes = Dashes;
// Obtain handles for animated properties
DUCE.ResourceHandle hOffsetAnimations = GetAnimationResourceHandle(OffsetProperty, channel);
// Store the count of this resource's contained collections in local variables.
int DashesCount = (vDashes == null) ? 0 : vDashes.Count;
// Pack & send command packet
DUCE.MILCMD_DASHSTYLE data;
unsafe
{
data.Type = MILCMD.MilCmdDashStyle;
data.Handle = _duceResource.GetHandle(channel);
if (hOffsetAnimations.IsNull)
{
data.Offset = Offset;
}
data.hOffsetAnimations = hOffsetAnimations;
data.DashesSize = (uint)(sizeof(Double) * DashesCount);
channel.BeginCommand(
(byte *)&data,
sizeof(DUCE.MILCMD_DASHSTYLE),
(int)(data.DashesSize)
);
// Copy this collection's elements (or their handles) to reserved data
for (int i = 0; i < DashesCount; i++)
{
Double resource = vDashes.Internal_GetItem(i);
channel.AppendCommandData(
(byte *)&resource,
sizeof(Double)
);
}
channel.EndCommand();
}
}
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
{
// If we're told we can skip the channel check, then we must be on channel
Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));
if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
{
base.UpdateResource(channel, skipOnChannelCheck);
// Read values of properties into local variables
MaterialCollection vChildren = Children;
// Store the count of this resource's contained collections in local variables.
int ChildrenCount = (vChildren == null) ? 0 : vChildren.Count;
// Pack & send command packet
DUCE.MILCMD_MATERIALGROUP data;
unsafe
{
data.Type = MILCMD.MilCmdMaterialGroup;
data.Handle = _duceResource.GetHandle(channel);
data.ChildrenSize = (uint)(sizeof(DUCE.ResourceHandle) * ChildrenCount);
channel.BeginCommand(
(byte *)&data,
sizeof(DUCE.MILCMD_MATERIALGROUP),
(int)(data.ChildrenSize)
);
// Copy this collection's elements (or their handles) to reserved data
for (int i = 0; i < ChildrenCount; i++)
{
DUCE.ResourceHandle resource = ((DUCE.IResource)vChildren.Internal_GetItem(i)).GetHandle(channel);;
channel.AppendCommandData(
(byte *)&resource,
sizeof(DUCE.ResourceHandle)
);
}
channel.EndCommand();
}
}
}
private void ManualUpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
{
// If we're told we can skip the channel check, then we must be on channel
Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));
if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
{
checked
{
DUCE.MILCMD_PIXELSHADER data;
data.Type = MILCMD.MilCmdPixelShader;
data.Handle = _duceResource.GetHandle(channel);
data.PixelShaderBytecodeSize = (_shaderBytecode.Value == null) ? 0 : (uint)(_shaderBytecode.Value).Length;
data.ShaderRenderMode = ShaderRenderMode;
data.CompileSoftwareShader = CompositionResourceManager.BooleanToUInt32(!(ShaderMajorVersion == 3 && ShaderMinorVersion == 0));
unsafe
{
channel.BeginCommand(
(byte *)&data,
sizeof(DUCE.MILCMD_PIXELSHADER),
(int)data.PixelShaderBytecodeSize); // extra data
if (data.PixelShaderBytecodeSize > 0)
{
fixed(byte *pPixelShaderBytecode = _shaderBytecode.Value)
{
channel.AppendCommandData(pPixelShaderBytecode, (int)data.PixelShaderBytecodeSize);
}
}
}
}
channel.EndCommand();
}
}
private void ManualUpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
{
// If we're told we can skip the channel check, then we must be on channel
Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));
if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
{
if (PixelShader == null)
{
throw new InvalidOperationException(SR.Get(SRID.Effect_ShaderPixelShaderSet));
}
checked
{
DUCE.MILCMD_SHADEREFFECT data;
data.Type = MILCMD.MilCmdShaderEffect;
data.Handle = _duceResource.GetHandle(channel);
data.TopPadding = _topPadding;
data.BottomPadding = _bottomPadding;
data.LeftPadding = _leftPadding;
data.RightPadding = _rightPadding;
data.DdxUvDdyUvRegisterIndex = this.DdxUvDdyUvRegisterIndex;
data.hPixelShader = ((DUCE.IResource)PixelShader).GetHandle(channel);
unsafe
{
data.ShaderConstantFloatRegistersSize = (uint)(sizeof(Int16) * _floatCount);
data.DependencyPropertyFloatValuesSize = (uint)(4 * sizeof(Single) * _floatCount);
data.ShaderConstantIntRegistersSize = (uint)(sizeof(Int16) * _intCount);
data.DependencyPropertyIntValuesSize = (uint)(4 * sizeof(Int32) * _intCount);
data.ShaderConstantBoolRegistersSize = (uint)(sizeof(Int16) * _boolCount);
//
// Note: the multiply by 4 is not because the boolean register holds 4
// values, but to compensate for the difference between sizeof(bool)
// in managed code (1) and sizeof(BOOL) in native code (4).
//
data.DependencyPropertyBoolValuesSize = (uint)(4 * sizeof(bool) * _boolCount);
data.ShaderSamplerRegistrationInfoSize = (uint)(2 * sizeof(uint) * _samplerCount); // 2 pieces of data per sampler.
data.DependencyPropertySamplerValuesSize = (uint)(1 * sizeof(DUCE.ResourceHandle) * _samplerCount);
channel.BeginCommand(
(byte *)&data,
sizeof(DUCE.MILCMD_SHADEREFFECT),
(int)(data.ShaderConstantFloatRegistersSize +
data.DependencyPropertyFloatValuesSize +
data.ShaderConstantIntRegistersSize +
data.DependencyPropertyIntValuesSize +
data.ShaderConstantBoolRegistersSize +
data.DependencyPropertyBoolValuesSize +
data.ShaderSamplerRegistrationInfoSize +
data.DependencyPropertySamplerValuesSize)
);
// Arrays appear in this order:
// 1) float register indices
// 2) float dp values
// 3) int register indices
// 4) int dp values
// 5) bool register indices
// 6) bool dp values
// 7) sampler registration info
// 8) sampler dp values
// 1) float register indices
AppendRegisters(channel, _floatRegisters);
// 2) float dp values
if (_floatRegisters != null)
{
for (int i = 0; i < _floatRegisters.Count; i++)
{
MilColorF?v = _floatRegisters[i];
if (v.HasValue)
{
MilColorF valueToPush = v.Value;
channel.AppendCommandData((byte *)&valueToPush, sizeof(MilColorF));
}
}
}
// 3) int register indices
AppendRegisters(channel, _intRegisters);
// 4) int dp values
if (_intRegisters != null)
{
for (int i = 0; i < _intRegisters.Count; i++)
{
MilColorI?v = _intRegisters[i];
if (v.HasValue)
{
MilColorI valueToPush = v.Value;
channel.AppendCommandData((byte *)&valueToPush, sizeof(MilColorI));
}
}
}
// 5) bool register indices
AppendRegisters(channel, _boolRegisters);
// 6) bool dp values
if (_boolRegisters != null)
{
for (int i = 0; i < _boolRegisters.Count; i++)
{
bool?v = _boolRegisters[i];
if (v.HasValue)
{
//
// Note: need 4 bytes for the bool, because the render thread
// unmarshals it into a 4-byte BOOL. See the comment above for
// DependencyPropertyBoolValuesSize for more details.
//
Int32 valueToPush = v.Value ? 1 : 0;
channel.AppendCommandData((byte *)&valueToPush, sizeof(Int32));
}
}
}
// 7) sampler registration info
if (_samplerCount > 0)
{
int count = _samplerData.Count;
for (int i = 0; i < count; i++)
{
SamplerData?ssn = _samplerData[i];
if (ssn.HasValue)
{
SamplerData ss = ssn.Value;
// add as a 2-tuple (SamplerRegisterIndex,
// SamplingMode)
channel.AppendCommandData((byte *)&i, sizeof(int));
int value = (int)(ss._samplingMode);
channel.AppendCommandData((byte *)&value, sizeof(int));
}
}
}
// 8) sampler dp values
if (_samplerCount > 0)
{
for (int i = 0; i < _samplerData.Count; i++)
{
SamplerData?ssn = _samplerData[i];
if (ssn.HasValue)
{
SamplerData ss = ssn.Value;
// Making this assumption by storing a collection of
// handles as an Int32Collection
Debug.Assert(sizeof(DUCE.ResourceHandle) == sizeof(Int32));
DUCE.ResourceHandle hBrush = ss._brush != null
? ((DUCE.IResource)ss._brush).GetHandle(channel)
: DUCE.ResourceHandle.Null;
Debug.Assert(!hBrush.IsNull || ss._brush == null, "If brush isn't null, hBrush better not be");
channel.AppendCommandData((byte *)&hBrush, sizeof(DUCE.ResourceHandle));
}
}
}
// That's it...
channel.EndCommand();
}
}
}
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
{
// If we're told we can skip the channel check, then we must be on channel
Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));
if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
{
base.UpdateResource(channel, skipOnChannelCheck);
// Read values of properties into local variables
DrawingCollection vChildren = Children;
Geometry vClipGeometry = ClipGeometry;
Brush vOpacityMask = OpacityMask;
Transform vTransform = Transform;
GuidelineSet vGuidelineSet = GuidelineSet;
// Obtain handles for properties that implement DUCE.IResource
DUCE.ResourceHandle hClipGeometry = vClipGeometry != null ? ((DUCE.IResource)vClipGeometry).GetHandle(channel) : DUCE.ResourceHandle.Null;
DUCE.ResourceHandle hOpacityMask = vOpacityMask != null ? ((DUCE.IResource)vOpacityMask).GetHandle(channel) : DUCE.ResourceHandle.Null;
DUCE.ResourceHandle hTransform;
if (vTransform == null ||
Object.ReferenceEquals(vTransform, Transform.Identity)
)
{
hTransform = DUCE.ResourceHandle.Null;
}
else
{
hTransform = ((DUCE.IResource)vTransform).GetHandle(channel);
}
DUCE.ResourceHandle hGuidelineSet = vGuidelineSet != null ? ((DUCE.IResource)vGuidelineSet).GetHandle(channel) : DUCE.ResourceHandle.Null;
// Obtain handles for animated properties
DUCE.ResourceHandle hOpacityAnimations = GetAnimationResourceHandle(OpacityProperty, channel);
// Store the count of this resource's contained collections in local variables.
int ChildrenCount = (vChildren == null) ? 0 : vChildren.Count;
// Pack & send command packet
DUCE.MILCMD_DRAWINGGROUP data;
unsafe
{
data.Type = MILCMD.MilCmdDrawingGroup;
data.Handle = _duceResource.GetHandle(channel);
data.ChildrenSize = (uint)(sizeof(DUCE.ResourceHandle) * ChildrenCount);
data.hClipGeometry = hClipGeometry;
if (hOpacityAnimations.IsNull)
{
data.Opacity = Opacity;
}
data.hOpacityAnimations = hOpacityAnimations;
data.hOpacityMask = hOpacityMask;
data.hTransform = hTransform;
data.hGuidelineSet = hGuidelineSet;
data.EdgeMode = (EdgeMode)GetValue(RenderOptions.EdgeModeProperty);
data.bitmapScalingMode = (BitmapScalingMode)GetValue(RenderOptions.BitmapScalingModeProperty);
data.ClearTypeHint = (ClearTypeHint)GetValue(RenderOptions.ClearTypeHintProperty);
channel.BeginCommand(
(byte *)&data,
sizeof(DUCE.MILCMD_DRAWINGGROUP),
(int)(data.ChildrenSize)
);
// Copy this collection's elements (or their handles) to reserved data
for (int i = 0; i < ChildrenCount; i++)
{
DUCE.ResourceHandle resource = ((DUCE.IResource)vChildren.Internal_GetItem(i)).GetHandle(channel);;
channel.AppendCommandData(
(byte *)&resource,
sizeof(DUCE.ResourceHandle)
);
}
channel.EndCommand();
}
}
}
private void ManualUpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
{
// If we're told we can skip the channel check, then we must be on channel
Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));
if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
{
Transform vTransform = Transform;
Transform vRelativeTransform = RelativeTransform;
GradientStopCollection vGradientStops = GradientStops;
DUCE.ResourceHandle hTransform;
if (vTransform == null ||
Object.ReferenceEquals(vTransform, Transform.Identity)
)
{
hTransform = DUCE.ResourceHandle.Null;
}
else
{
hTransform = ((DUCE.IResource)vTransform).GetHandle(channel);
}
DUCE.ResourceHandle hRelativeTransform;
if (vRelativeTransform == null ||
Object.ReferenceEquals(vRelativeTransform, Transform.Identity)
)
{
hRelativeTransform = DUCE.ResourceHandle.Null;
}
else
{
hRelativeTransform = ((DUCE.IResource)vRelativeTransform).GetHandle(channel);
}
DUCE.ResourceHandle hOpacityAnimations = GetAnimationResourceHandle(OpacityProperty, channel);
DUCE.ResourceHandle hCenterAnimations = GetAnimationResourceHandle(CenterProperty, channel);
DUCE.ResourceHandle hRadiusXAnimations = GetAnimationResourceHandle(RadiusXProperty, channel);
DUCE.ResourceHandle hRadiusYAnimations = GetAnimationResourceHandle(RadiusYProperty, channel);
DUCE.ResourceHandle hGradientOriginAnimations = GetAnimationResourceHandle(GradientOriginProperty, channel);
DUCE.MILCMD_RADIALGRADIENTBRUSH data;
unsafe
{
data.Type = MILCMD.MilCmdRadialGradientBrush;
data.Handle = _duceResource.GetHandle(channel);
double tempOpacity = Opacity;
DUCE.CopyBytes((byte *)&data.Opacity, (byte *)&tempOpacity, 8);
data.hOpacityAnimations = hOpacityAnimations;
data.hTransform = hTransform;
data.hRelativeTransform = hRelativeTransform;
data.ColorInterpolationMode = ColorInterpolationMode;
data.MappingMode = MappingMode;
data.SpreadMethod = SpreadMethod;
Point tempCenter = Center;
DUCE.CopyBytes((byte *)&data.Center, (byte *)&tempCenter, 16);
data.hCenterAnimations = hCenterAnimations;
double tempRadiusX = RadiusX;
DUCE.CopyBytes((byte *)&data.RadiusX, (byte *)&tempRadiusX, 8);
data.hRadiusXAnimations = hRadiusXAnimations;
double tempRadiusY = RadiusY;
DUCE.CopyBytes((byte *)&data.RadiusY, (byte *)&tempRadiusY, 8);
data.hRadiusYAnimations = hRadiusYAnimations;
Point tempGradientOrigin = GradientOrigin;
DUCE.CopyBytes((byte *)&data.GradientOrigin, (byte *)&tempGradientOrigin, 16);
data.hGradientOriginAnimations = hGradientOriginAnimations;
// NTRAID#Longhorn-1011154-2004/8/12-asecchia GradientStopCollection: Need to enforce upper-limit of gradient stop capacity
int count = (vGradientStops == null) ? 0 : vGradientStops.Count;
data.GradientStopsSize = (UInt32)(sizeof(DUCE.MIL_GRADIENTSTOP) * count);
channel.BeginCommand(
(byte *)&data,
sizeof(DUCE.MILCMD_RADIALGRADIENTBRUSH),
sizeof(DUCE.MIL_GRADIENTSTOP) * count
);
for (int i = 0; i < count; i++)
{
DUCE.MIL_GRADIENTSTOP stopCmd;
GradientStop gradStop = vGradientStops.Internal_GetItem(i);
double temp = gradStop.Offset;
DUCE.CopyBytes((byte *)&stopCmd.Position, (byte *)&temp, sizeof(double));
stopCmd.Color = CompositionResourceManager.ColorToMilColorF(gradStop.Color);
channel.AppendCommandData(
(byte *)&stopCmd,
sizeof(DUCE.MIL_GRADIENTSTOP)
);
}
channel.EndCommand();
}
}
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
{
// If we're told we can skip the channel check, then we must be on channel
Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));
if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
{
base.UpdateResource(channel, skipOnChannelCheck);
// Read values of properties into local variables
Point3DCollection vPositions = Positions;
Vector3DCollection vNormals = Normals;
PointCollection vTextureCoordinates = TextureCoordinates;
Int32Collection vTriangleIndices = TriangleIndices;
// Store the count of this resource's contained collections in local variables.
int PositionsCount = (vPositions == null) ? 0 : vPositions.Count;
int NormalsCount = (vNormals == null) ? 0 : vNormals.Count;
int TextureCoordinatesCount = (vTextureCoordinates == null) ? 0 : vTextureCoordinates.Count;
int TriangleIndicesCount = (vTriangleIndices == null) ? 0 : vTriangleIndices.Count;
// Pack & send command packet
DUCE.MILCMD_MESHGEOMETRY3D data;
unsafe
{
data.Type = MILCMD.MilCmdMeshGeometry3D;
data.Handle = _duceResource.GetHandle(channel);
data.PositionsSize = (uint)(sizeof(MilPoint3F) * PositionsCount);
data.NormalsSize = (uint)(sizeof(MilPoint3F) * NormalsCount);
data.TextureCoordinatesSize = (uint)(sizeof(Point) * TextureCoordinatesCount);
data.TriangleIndicesSize = (uint)(sizeof(Int32) * TriangleIndicesCount);
channel.BeginCommand(
(byte *)&data,
sizeof(DUCE.MILCMD_MESHGEOMETRY3D),
(int)(data.PositionsSize +
data.NormalsSize +
data.TextureCoordinatesSize +
data.TriangleIndicesSize)
);
// Copy this collection's elements (or their handles) to reserved data
for (int i = 0; i < PositionsCount; i++)
{
MilPoint3F resource = CompositionResourceManager.Point3DToMilPoint3F(vPositions.Internal_GetItem(i));
channel.AppendCommandData(
(byte *)&resource,
sizeof(MilPoint3F)
);
}
// Copy this collection's elements (or their handles) to reserved data
for (int i = 0; i < NormalsCount; i++)
{
MilPoint3F resource = CompositionResourceManager.Vector3DToMilPoint3F(vNormals.Internal_GetItem(i));
channel.AppendCommandData(
(byte *)&resource,
sizeof(MilPoint3F)
);
}
// Copy this collection's elements (or their handles) to reserved data
for (int i = 0; i < TextureCoordinatesCount; i++)
{
Point resource = vTextureCoordinates.Internal_GetItem(i);
channel.AppendCommandData(
(byte *)&resource,
sizeof(Point)
);
}
// Copy this collection's elements (or their handles) to reserved data
for (int i = 0; i < TriangleIndicesCount; i++)
{
Int32 resource = vTriangleIndices.Internal_GetItem(i);
channel.AppendCommandData(
(byte *)&resource,
sizeof(Int32)
);
}
channel.EndCommand();
}
}
}
private void ManualUpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
{
// If we're told we can skip the channel check, then we must be on channel
Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));
if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
{
Transform vTransform = Transform;
Transform vRelativeTransform = RelativeTransform;
GradientStopCollection vGradientStops = GradientStops;
DUCE.ResourceHandle hTransform;
if (vTransform == null ||
Object.ReferenceEquals(vTransform, Transform.Identity)
)
{
hTransform = DUCE.ResourceHandle.Null;
}
else
{
hTransform = ((DUCE.IResource)vTransform).GetHandle(channel);
}
DUCE.ResourceHandle hRelativeTransform;
if (vRelativeTransform == null ||
Object.ReferenceEquals(vRelativeTransform, Transform.Identity)
)
{
hRelativeTransform = DUCE.ResourceHandle.Null;
}
else
{
hRelativeTransform = ((DUCE.IResource)vRelativeTransform).GetHandle(channel);
}
DUCE.ResourceHandle hOpacityAnimations = GetAnimationResourceHandle(OpacityProperty, channel);
DUCE.ResourceHandle hStartPointAnimations = GetAnimationResourceHandle(StartPointProperty, channel);
DUCE.ResourceHandle hEndPointAnimations = GetAnimationResourceHandle(EndPointProperty, channel);
unsafe
{
DUCE.MILCMD_LINEARGRADIENTBRUSH data;
data.Type = MILCMD.MilCmdLinearGradientBrush;
data.Handle = _duceResource.GetHandle(channel);
double tempOpacity = Opacity;
DUCE.CopyBytes((byte *)&data.Opacity, (byte *)&tempOpacity, 8);
data.hOpacityAnimations = hOpacityAnimations;
data.hTransform = hTransform;
data.hRelativeTransform = hRelativeTransform;
data.ColorInterpolationMode = ColorInterpolationMode;
data.MappingMode = MappingMode;
data.SpreadMethod = SpreadMethod;
Point tempStartPoint = StartPoint;
DUCE.CopyBytes((byte *)&data.StartPoint, (byte *)&tempStartPoint, 16);
data.hStartPointAnimations = hStartPointAnimations;
Point tempEndPoint = EndPoint;
DUCE.CopyBytes((byte *)&data.EndPoint, (byte *)&tempEndPoint, 16);
data.hEndPointAnimations = hEndPointAnimations;
// GradientStopCollection: Need to enforce upper-limit of gradient stop capacity
int count = (vGradientStops == null) ? 0 : vGradientStops.Count;
data.GradientStopsSize = (UInt32)(sizeof(DUCE.MIL_GRADIENTSTOP) * count);
channel.BeginCommand(
(byte *)&data,
sizeof(DUCE.MILCMD_LINEARGRADIENTBRUSH),
sizeof(DUCE.MIL_GRADIENTSTOP) * count
);
for (int i = 0; i < count; i++)
{
DUCE.MIL_GRADIENTSTOP stopCmd;
GradientStop gradStop = vGradientStops.Internal_GetItem(i);
double temp = gradStop.Offset;
DUCE.CopyBytes((byte *)&stopCmd.Position, (byte *)&temp, sizeof(double));
stopCmd.Color = CompositionResourceManager.ColorToMilColorF(gradStop.Color);
channel.AppendCommandData(
(byte *)&stopCmd,
sizeof(DUCE.MIL_GRADIENTSTOP)
);
}
channel.EndCommand();
}
}
}