protected override void DrawGeometry(Matrix view, Matrix projection, object[] optionalParameters, EffectConfigurer effectConfigurer, RendererParameters instance)
{
effectConfigurer(mEffect, instance, optionalParameters);
GraphicsManager.Device.SamplerStates[0] = SamplerState.PointClamp;
SkyBoxParameters skyBoxInstance = instance as SkyBoxParameters;
GraphicsManager.Device.SamplerStates[0] = SamplerState.LinearWrap;
Vector3 sceneScale = new Vector3(Scale, Scale, Scale);
Vector3 centerOffset = new Vector3(0, sceneScale.Y * 0.5f, 0);
mEffect.World = Matrix.CreateScale(sceneScale) * skyBoxInstance.World * Matrix.CreateTranslation(-centerOffset);
mEffect.View = view;
mEffect.Projection = Matrix.CreatePerspectiveFieldOfView(GraphicsManager.Camera.FieldOfView, GraphicsManager.Camera.AspectRatio, GraphicsManager.Camera.NearPlaneDistance, Scale); ;
mEffect.Parameters["xOverlayColor"].SetValue(skyBoxInstance.OverlayColor.ToVector3());
mEffect.Parameters["xOverlayColorWeight"].SetValue(skyBoxInstance.OverlayWeight);
mEffect.Parameters["xTextureOffset"].SetValue(skyBoxInstance.TextureAnimationOffset);
mEffect.Parameters["xTextureTransformation"].SetValue(Matrix.Identity);
mEffect.Parameters["xIsBeingSpaghettified"].SetValue(false);
mEffect.Texture = AssetLibrary.LookupTexture(skyBoxInstance.TextureName);
GraphicsManager.Device.SetVertexBuffer(mVertexBuffer);
GraphicsManager.Device.Indices = mIndexBuffer;
mEffect.CurrentTechnique.Passes[0].Apply();
GraphicsManager.Device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, mVertexBuffer.VertexCount, 0, mIndexBuffer.IndexCount / 3);
}
protected override void DrawGeometry(Matrix view, Matrix projection, object[] optionalParameters, EffectConfigurer effectConfigurer, RendererParameters instance)
{
effectConfigurer(mEffect, instance, optionalParameters);
WaterParameters waterInstance = instance as WaterParameters;
GraphicsManager.Device.SamplerStates[0] = SamplerState.LinearWrap;
mEffect.World = Matrix.CreateScale(1.0f, waterInstance.SeaLevel, 1.0f) * waterInstance.World;
mEffect.View = view;
mEffect.Projection = projection;
mEffect.Parameters["xOverlayColor"].SetValue(waterInstance.OverlayColor.ToVector3());
mEffect.Parameters["xOverlayColorWeight"].SetValue(waterInstance.OverlayWeight);
mEffect.Parameters["xTextureOffset"].SetValue(waterInstance.TextureAnimationOffset);
mEffect.Texture = AssetLibrary.LookupTexture(waterInstance.TextureName);
mEffect.Parameters["xIsBeingSpaghettified"].SetValue(false);
GraphicsManager.Device.SetVertexBuffer(mVertexBuffer);
GraphicsManager.Device.Indices = mIndexBuffer;
mEffect.CurrentTechnique.Passes[0].Apply();
GraphicsManager.Device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, mVertexBuffer.VertexCount, 0, mIndexBuffer.IndexCount / 3);
}
protected override void DrawGeometry(Matrix view, Matrix projection, object[] optionalParameters, EffectConfigurer effectConfigurer, RendererParameters instance)
{
ModelParameters modelInstance = instance as ModelParameters;
if (modelInstance != null && modelInstance.TryCull && GraphicsManager.ViewBoundingFrustum.Contains(modelInstance.BoundingBox) == ContainmentType.Disjoint)
{
return;
}
foreach (ModelMesh mesh in mModel.Meshes)
{
foreach (AnimationUtilities.SkinnedEffect effect in mesh.Effects)
{
effect.World = modelInstance.World;
effect.View = view;
effect.Projection = projection;
effect.Parameters["xOverlayColor"].SetValue(modelInstance.OverlayColor.ToVector3());
effect.Parameters["xOverlayColorWeight"].SetValue(modelInstance.OverlayWeight);
effect.Parameters["xTextureOffset"].SetValue(modelInstance.TextureAnimationOffset);
effect.Parameters["xIsBeingSpaghettified"].SetValue(modelInstance.Spaghettify);
effect.Parameters["xWormholePosition"].SetValue(modelInstance.WormholePosition);
effect.Parameters["xMaxWormholeDistance"].SetValue(modelInstance.MaxWormholeDistance);
effect.Parameters["xModelWormholeDistance"].SetValue((modelInstance.WormholePosition - modelInstance.World.Translation).Length());
effectConfigurer(effect, modelInstance, optionalParameters);
}
mesh.Draw();
}
}
protected override void NormalDepthConfigurer(AnimationUtilities.SkinnedEffect effect, RendererParameters instance, object[] optionalParameters)
{
base.NormalDepthConfigurer(effect, instance, optionalParameters);
Matrix[] skinTransforms = new Matrix[] { Matrix.Identity };
if (instance is AnimateModelParameters)
{
skinTransforms = ((instance as AnimateModelParameters).SkinTransforms);
}
effect.SetBoneTransforms(skinTransforms);
effect.CurrentTechnique = effect.Techniques["SkinnedNormalDepthShade"];
}
public void TextUtilsRendererParametersIsTextColorSet()
{
tlog.Debug(tag, $"TextUtilsRendererParametersIsTextColorSet START");
var testingTarget = new RendererParameters();
Assert.IsNotNull(testingTarget, "Can't create success object RendererParameters");
Assert.IsInstanceOf <RendererParameters>(testingTarget, "Should be an instance of RendererParameters type.");
testingTarget.TextColor = Color.Cyan;
Assert.AreEqual(true, testingTarget.IsTextColorSet, "Should be equal!");
testingTarget.Dispose();
tlog.Debug(tag, $"TextUtilsRendererParametersIsTextColorSet END (OK)");
}
public void TextUtilsRendererParametersFontSize()
{
tlog.Debug(tag, $"TextUtilsRendererParametersFontSize START");
var testingTarget = new RendererParameters();
Assert.IsNotNull(testingTarget, "Can't create success object RendererParameters");
Assert.IsInstanceOf <RendererParameters>(testingTarget, "Should be an instance of RendererParameters type.");
testingTarget.FontSize = 15.0f;
Assert.AreEqual(15.0f, testingTarget.FontSize, "Should be equal!");
testingTarget.Dispose();
tlog.Debug(tag, $"TextUtilsRendererParametersFontSize END (OK)");
}
public void TextUtilsRendererParametersTextWidth()
{
tlog.Debug(tag, $"TextUtilsRendererParametersTextWidth START");
var testingTarget = new RendererParameters();
Assert.IsNotNull(testingTarget, "Can't create success object RendererParameters");
Assert.IsInstanceOf <RendererParameters>(testingTarget, "Should be an instance of RendererParameters type.");
testingTarget.TextWidth = 32;
Assert.AreEqual(32, testingTarget.TextWidth, "Should be equal!");
testingTarget.Dispose();
tlog.Debug(tag, $"TextUtilsRendererParametersTextWidth END (OK)");
}
public void TextUtilsRendererParametersMarkupEnabled()
{
tlog.Debug(tag, $"TextUtilsRendererParametersMarkupEnabled START");
var testingTarget = new RendererParameters();
Assert.IsNotNull(testingTarget, "Can't create success object RendererParameters");
Assert.IsInstanceOf <RendererParameters>(testingTarget, "Should be an instance of RendererParameters type.");
testingTarget.Layout = TextLayout.SingleLine;
testingTarget.MarkupEnabled = true;
Assert.AreEqual(true, testingTarget.MarkupEnabled, "Should be equal!");
testingTarget.Dispose();
tlog.Debug(tag, $"TextUtilsRendererParametersMarkupEnabled END (OK)");
}
public void TextUtilsRendererParametersTextColor()
{
tlog.Debug(tag, $"TextUtilsRendererParametersTextColor START");
var testingTarget = new RendererParameters();
Assert.IsNotNull(testingTarget, "Can't create success object RendererParameters");
Assert.IsInstanceOf <RendererParameters>(testingTarget, "Should be an instance of RendererParameters type.");
testingTarget.TextColor = new Vector4(0.3f, 0.8f, 1.0f, 0.0f);
Assert.AreEqual(0.3f, testingTarget.TextColor.R, "Should be equal!");
Assert.AreEqual(0.8f, testingTarget.TextColor.G, "Should be equal!");
Assert.AreEqual(1.0f, testingTarget.TextColor.B, "Should be equal!");
Assert.AreEqual(0.0f, testingTarget.TextColor.A, "Should be equal!");
testingTarget.Dispose();
tlog.Debug(tag, $"TextUtilsRendererParametersTextColor END (OK)");
}
public void TextUtilsRendererParametersPadding()
{
tlog.Debug(tag, $"TextUtilsRendererParametersPadding START");
var testingTarget = new RendererParameters();
Assert.IsNotNull(testingTarget, "Can't create success object RendererParameters");
Assert.IsInstanceOf <RendererParameters>(testingTarget, "Should be an instance of RendererParameters type.");
testingTarget.Padding = new Extents(4, 4, 4, 4);
Assert.AreEqual(4, testingTarget.Padding.Start, "Should be equal!");
Assert.AreEqual(4, testingTarget.Padding.End, "Should be equal!");
Assert.AreEqual(4, testingTarget.Padding.Top, "Should be equal!");
Assert.AreEqual(4, testingTarget.Padding.Bottom, "Should be equal!");
testingTarget.Dispose();
tlog.Debug(tag, $"TextUtilsRendererParametersPadding END (OK)");
}
/// <summary>
/// Returns the chart renderer appropriate for the chart.
/// </summary>
private ChartRenderer GetChartRenderer(Chart chart, RendererParameters parms)
{
ChartType chartType = chart.Type;
bool useCombinationRenderer = false;
foreach (Series series in chart.seriesCollection)
{
if (series.chartType != chartType)
{
useCombinationRenderer = true;
break;
}
}
if (useCombinationRenderer)
{
return(new CombinationChartRenderer(parms));
}
switch (chartType)
{
case ChartType.Line:
return(new LineChartRenderer(parms));
case ChartType.Column2D:
case ChartType.ColumnStacked2D:
return(new ColumnChartRenderer(parms));
case ChartType.Bar2D:
case ChartType.BarStacked2D:
return(new BarChartRenderer(parms));
case ChartType.Area2D:
return(new AreaChartRenderer(parms));
case ChartType.Pie2D:
case ChartType.PieExploded2D:
return(new PieChartRenderer(parms));
}
return(null);
}
/// <summary>
/// Draws first chart only.
/// </summary>
public void DrawChart(XGraphics gfx)
{
XGraphicsState state = gfx.Save();
gfx.TranslateTransform(this.location.X, this.location.Y);
if (this.chartList.Count > 0)
{
XRect chartRect = new XRect(0, 0, this.size.Width, this.size.Height);
Chart chart = (Chart)this.chartList[0];
RendererParameters parms = new RendererParameters(gfx, chartRect);
parms.DrawingItem = chart;
ChartRenderer renderer = GetChartRenderer(chart, parms);
renderer.Init();
renderer.Format();
renderer.Draw();
}
gfx.Restore(state);
}
public void TextUtilsRendererParametersLayout()
{
tlog.Debug(tag, $"TextUtilsRendererParametersLayout START");
var testingTarget = new RendererParameters();
Assert.IsNotNull(testingTarget, "Can't create success object RendererParameters");
Assert.IsInstanceOf <RendererParameters>(testingTarget, "Should be an instance of RendererParameters type.");
testingTarget.Layout = TextLayout.MultiLine;
Assert.AreEqual(TextLayout.MultiLine, testingTarget.Layout, "Should be equal!");
testingTarget.Layout = TextLayout.Circular;
Assert.AreEqual(TextLayout.Circular, testingTarget.Layout, "Should be equal!");
testingTarget.Layout = TextLayout.SingleLine;
Assert.AreEqual(TextLayout.SingleLine, testingTarget.Layout, "Should be equal!");
testingTarget.Dispose();
tlog.Debug(tag, $"TextUtilsRendererParametersLayout END (OK)");
}
public void TextUtilsRendererParametersHorizontalAlignment()
{
tlog.Debug(tag, $"TextUtilsRendererParametersHorizontalAlignment START");
var testingTarget = new RendererParameters();
Assert.IsNotNull(testingTarget, "Can't create success object RendererParameters");
Assert.IsInstanceOf <RendererParameters>(testingTarget, "Should be an instance of RendererParameters type.");
testingTarget.HorizontalAlignment = HorizontalAlignment.Begin;
Assert.AreEqual(HorizontalAlignment.Begin, testingTarget.HorizontalAlignment, "Should be equal!");
testingTarget.HorizontalAlignment = HorizontalAlignment.Center;
Assert.AreEqual(HorizontalAlignment.Center, testingTarget.HorizontalAlignment, "Should be equal!");
testingTarget.HorizontalAlignment = HorizontalAlignment.End;
Assert.AreEqual(HorizontalAlignment.End, testingTarget.HorizontalAlignment, "Should be equal!");
testingTarget.Dispose();
tlog.Debug(tag, $"TextUtilsRendererParametersHorizontalAlignment END (OK)");
}
public void TextUtilsRendererParametersVerticalAlignment()
{
tlog.Debug(tag, $"TextUtilsRendererParametersVerticalAlignment START");
var testingTarget = new RendererParameters();
Assert.IsNotNull(testingTarget, "Can't create success object RendererParameters");
Assert.IsInstanceOf <RendererParameters>(testingTarget, "Should be an instance of RendererParameters type.");
testingTarget.VerticalAlignment = VerticalAlignment.Bottom;
Assert.AreEqual(VerticalAlignment.Bottom, testingTarget.VerticalAlignment, "Should be equal!");
testingTarget.VerticalAlignment = VerticalAlignment.Top;
Assert.AreEqual(VerticalAlignment.Top, testingTarget.VerticalAlignment, "Should be equal!");
testingTarget.VerticalAlignment = VerticalAlignment.Center;
Assert.AreEqual(VerticalAlignment.Center, testingTarget.VerticalAlignment, "Should be equal!");
testingTarget.Dispose();
tlog.Debug(tag, $"TextUtilsRendererParametersVerticalAlignment END (OK)");
}
/// <summary>
/// Initializes a new instance of the Renderer class with the specified renderer parameters.
/// </summary>
internal Renderer(RendererParameters rendererParms)
{
_rendererParms = rendererParms;
}
/// <summary>
/// Initializes a new instance of the GridlinesRenderer class with the specified renderer parameters.
/// </summary>
internal GridlinesRenderer(RendererParameters parms)
: base(parms)
{
}
protected override void DrawGeometry(Matrix view, Matrix projection, object[] optionalParameters, EffectConfigurer effectConfigurer, RendererParameters instance)
{
HeightMapParameters terrainInstance = instance as HeightMapParameters;
if (terrainInstance.TryCull && GraphicsManager.ViewBoundingFrustum.Contains(terrainInstance.BoundingBox) == ContainmentType.Disjoint)
{
return;
}
for (int i = 0; i < 7; ++i)
{
GraphicsManager.Device.SamplerStates[i] = SamplerState.PointWrap;
}
GraphicsManager.Device.SamplerStates[2] = SamplerState.LinearClamp;
mEffect.World = instance.World;
mEffect.View = view;
mEffect.Projection = projection;
mEffect.Parameters["xOverlayColor"].SetValue(instance.OverlayColor.ToVector3());
mEffect.Parameters["xOverlayColorWeight"].SetValue(instance.OverlayWeight);
mEffect.Parameters["xTextureOffset"].SetValue(instance.TextureAnimationOffset);
//mEffect.Parameters["xIsBeingSpaghettified"].SetValue(false);
mEffect.Parameters["xDrawCursor"].SetValue((int)terrainInstance.DrawCursor);
if (terrainInstance.DrawCursor != HeightMapRenderable.CursorShape.NONE)
{
mEffect.Parameters["xCursorPosition"].SetValue(terrainInstance.CursorPosition);
mEffect.Parameters["xCursorInnerRadius"].SetValue(terrainInstance.CursorInnerRadius);
mEffect.Parameters["xCursorOuterRadius"].SetValue(terrainInstance.CursorOuterRadius);
}
mEffect.Parameters["xTextureMask"].SetValue(terrainInstance.TextureMask);
effectConfigurer(mEffect, instance, optionalParameters);
mEffect.Parameters["AlphaMap"].SetValue(mMesh.AlphaMap);
for (int i = 0; i < mMesh.DetailTextureNames.Length; ++i)
{
string detailTextureName = mMesh.DetailTextureNames[i];
Vector2 uvOffset = mMesh.DetailTextureUVOffset[i];
Vector2 uvScale = mMesh.DetailTextureUVScale[i];
if (detailTextureName != null)
{
mEffect.Parameters[LAYER_TEXTURE_NAMES[i]].SetValue(AssetLibrary.LookupTexture(detailTextureName));
mEffect.Parameters[LAYER_TEXTURE_NAMES[i] + "_uvOffset"].SetValue(uvOffset);
mEffect.Parameters[LAYER_TEXTURE_NAMES[i] + "_uvScale"].SetValue(uvScale);
}
}
VertexBuffer vertexBuffer = mMesh.VertexBuffer;
IndexBuffer indexBuffer = mMesh.IndexBuffer;
GraphicsManager.Device.SetVertexBuffer(vertexBuffer);
GraphicsManager.Device.Indices = indexBuffer;
mEffect.CurrentTechnique.Passes[0].Apply();
GraphicsManager.Device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, vertexBuffer.VertexCount, 0, indexBuffer.IndexCount / 3);
GraphicsManager.Device.SetVertexBuffer(null);
GraphicsManager.Device.Indices = null;
}
/// <summary>
/// Initializes a new instance of the GridlinesRenderer class with the specified renderer parameters.
/// </summary>
internal GridlinesRenderer(RendererParameters parms)
: base(parms)
{ }
protected override void WithoutShadowsConfigurer(AnimationUtilities.SkinnedEffect effect, RendererParameters instance, object[] optionalParameters)
{
Light light = optionalParameters[0] as Light;
effect.CurrentTechnique = effect.Techniques["CelShadeWithoutShadows"];
effect.Parameters["xDirLightDirection"].SetValue(light.Direction);
effect.Parameters["xDirLightDiffuseColor"].SetValue(light.DiffuseColor);
effect.Parameters["xDirLightSpecularColor"].SetValue(light.SpecularColor);
effect.Parameters["xDirLightAmbientColor"].SetValue(light.AmbientColor);
effect.SpecularColor = new Vector3(0.25f);
effect.SpecularPower = 16;
}
public void Activate()
{
Window window = NUIApplication.GetDefaultWindow();
root = new View()
{
Size = window.Size,
BackgroundColor = Color.Yellow,
ParentOrigin = ParentOrigin.TopLeft,
PivotPoint = PivotPoint.TopLeft,
PositionUsesPivotPoint = true,
};
window.Add(root);
string image1 = "<item 'width'=26 'height'=26 'url'='" + IMAGE1 + "'/>";
string image2 = "<item 'width'=26 'height'=26/>";
RendererParameters textParameters = new RendererParameters();
textParameters.Text = "Hello " + image1 + " world " + image2 + " this " + image1 + " is " + image2 + " a " + image1 + " demo " + image2 + " of " + image1 + " circular " + image2 + " text " + image1 + " width " + image2 + " icons.";
textParameters.HorizontalAlignment = HorizontalAlignment.Center;
textParameters.VerticalAlignment = VerticalAlignment.Center;
textParameters.CircularAlignment = CircularAlignment.Center;
textParameters.FontFamily = "SamsungUI";
textParameters.FontWeight = "";
textParameters.FontWidth = "";
textParameters.FontSlant = "";
textParameters.Layout = TextLayout.Circular;
textParameters.TextColor = Color.Black;
textParameters.FontSize = 25;
textParameters.TextWidth = 360u;
textParameters.TextHeight = 360u;
textParameters.Radius = 180u;
textParameters.BeginAngle = 15;
textParameters.IncrementAngle = 360;
textParameters.EllipsisEnabled = true;
textParameters.MarkupEnabled = true;
List <string> embeddedItems = new List <string>();
embeddedItems.Add(IMAGE2);
embeddedItems.Add(IMAGE2);
embeddedItems.Add(IMAGE2);
embeddedItems.Add(IMAGE2);
embeddedItems.Add(IMAGE2);
TextureSet textureSet = CreateTextureSet(textParameters, embeddedItems);
Renderer renderer = CreateRenderer();
renderer.SetTextures(textureSet);
View actor = new View();
actor.PivotPoint = PivotPoint.TopLeft;
actor.ParentOrigin = ParentOrigin.TopLeft;
actor.Position = new Position(0, 0, 0);
actor.Size = new Size(360, 360);
actor.Color = Color.White;
actor.AddRenderer(renderer);
root.Add(actor);
}
protected override void WithShadowsConfigurer(AnimationUtilities.SkinnedEffect effect, RendererParameters instance, object[] optionalParameters)
{
WithoutShadowsConfigurer(effect, instance, optionalParameters);
}
public int SetText(TextLabel label, string str)
{
if (label == null || str == null)
{
return(0);
}
// perform this operation to match the utf32 character used in native Dali.
bool previousMarkup = label.EnableMarkup;
label.EnableMarkup = false;
label.Text = str;
pageString = label.Text;
label.EnableMarkup = previousMarkup;
label.MultiLine = true;
label.Ellipsis = false;
int length = pageString.Length;
int remainLength = length;
int offset = 0;
int cutOffIndex = 0;
// init
totalPageCnt = 0;
pageList = new List <PageData>();
tagList = new List <TagData>();
characterList = new List <char>();
stream = new StringReader(pageString);
RendererParameters textParameters = new RendererParameters();
textParameters.Text = pageString;
textParameters.HorizontalAlignment = label.HorizontalAlignment;
textParameters.VerticalAlignment = label.VerticalAlignment;
textParameters.FontFamily = label.FontFamily;
textParameters.FontWeight = "";
textParameters.FontWidth = "";
textParameters.FontSlant = "";
textParameters.Layout = TextLayout.MultiLine;
textParameters.TextColor = Color.Black;
textParameters.FontSize = label.PointSize;
textParameters.TextWidth = (uint)label.Size.Width;
textParameters.TextHeight = (uint)label.Size.Height;
textParameters.EllipsisEnabled = true;
textParameters.MarkupEnabled = previousMarkup;
textParameters.MinLineSize = label.MinLineSize;
textParameters.Padding = label.Padding;
Tizen.NUI.PropertyArray cutOffIndexArray = TextUtils.GetLastCharacterIndex(textParameters);
uint count = cutOffIndexArray.Count();
for (uint i = 0; i < count; i++)
{
var temp = cutOffIndexArray.GetElementAt(i);
temp.Get(out cutOffIndex); // Gets the last index of text shown on the actual screen.
temp.Dispose();
// If markup is enabled, It should parse markup
if (label.EnableMarkup)
{
int preOffset = offset;
offset = MarkupProcess(offset, cutOffIndex - preOffset);
remainLength -= (offset - preOffset);
}
//If markup is not enabled, parsing is not required.
else
{
PageData pageData = new PageData();
pageData.StartOffset = offset;
int cnt = (cutOffIndex - offset) < remainLength ? (cutOffIndex - offset) : remainLength;
remainLength -= cnt;
offset += cnt;
pageData.EndOffset = offset;
pageList.Add(pageData);
}
totalPageCnt++;
if (offset <= 0 || remainLength <= 0)
{
break;
}
}
textParameters.Dispose();
cutOffIndexArray.Dispose();
stream = null;
return(totalPageCnt);
}
protected void RenderShadowMap(Matrix lightView, Matrix lightProjection, RendererParameters instance)
{
bool oldTryCull = instance.TryCull;
instance.TryCull = false;
DrawGeometry(Matrix.Identity, Matrix.Identity, new object[] { (Matrix?)lightView, (Matrix?)lightProjection }, mShadowMapConfigurer, instance);
instance.TryCull = oldTryCull;
}
protected void RenderNormalDepth(Matrix view, Matrix projection, RendererParameters instance)
{
DrawGeometry(view, projection, null, mNormalDepthConfigurer, instance);
}
protected abstract void DrawGeometry(Matrix view, Matrix projection, object[] optionalParameters, EffectConfigurer effectConfigurer, RendererParameters instance);
/// <summary>
/// Initializes a new instance of the XAxisRenderer class with the specified renderer parameters.
/// </summary>
internal XAxisRenderer(RendererParameters parms)
: base(parms)
{
}
/// <summary>
/// Initializes a new instance of the Renderer class with the specified renderer parameters.
/// </summary>
internal Renderer(RendererParameters rendererParms)
{
_rendererParms = rendererParms;
}
TextureSet CreateTextureSet(RendererParameters textParameters, List <string> embeddedItems)
{
EmbeddedItemInfo[] embeddedItemLayout = new EmbeddedItemInfo[0];
PixelBuffer pixelBuffer = TextUtils.Render(textParameters, ref embeddedItemLayout);
uint dstWidth = pixelBuffer.GetWidth();
uint dstHeight = pixelBuffer.GetHeight();
int index = 0;
int length = embeddedItemLayout.Length;
for (int i = 0; i < length; i++)
{
EmbeddedItemInfo itemLayout = embeddedItemLayout[i];
int width = (int)itemLayout.Size.Width;
int height = (int)itemLayout.Size.Height;
int x = (int)itemLayout.Position.X;
int y = (int)itemLayout.Position.Y;
PixelBuffer itemPixelBuffer = ImageLoading.LoadImageFromFile(embeddedItems[index++]);
if (itemPixelBuffer == null)
{
continue;
}
itemPixelBuffer.Resize((ushort)width, (ushort)height);
itemPixelBuffer.Rotate(itemLayout.Angle);
width = (int)itemPixelBuffer.GetWidth();
height = (int)itemPixelBuffer.GetHeight();
PixelFormat itemPixelFormat = itemPixelBuffer.GetPixelFormat();
// Check if the item is out of the buffer.
if ((x + width < 0) ||
(x > dstWidth) ||
(y < 0) ||
(y - height > dstHeight))
{
// The embedded item is completely out of the buffer.
continue;
}
// Crop if it exceeds the boundaries of the destination buffer.
int layoutX = 0;
int layoutY = 0;
int cropX = 0;
int cropY = 0;
int newWidth = width;
int newHeight = height;
bool crop = false;
if (0 > x)
{
newWidth += x;
cropX = Math.Abs(x);
crop = true;
}
else
{
layoutX = x;
}
if (cropX + newWidth > dstWidth)
{
crop = true;
newWidth -= (int)((cropX + newWidth) - dstWidth);
}
layoutY = y;
if (0 > layoutY)
{
newHeight += layoutY;
cropY = Math.Abs(layoutY);
crop = true;
}
if (cropY + newHeight > dstHeight)
{
crop = true;
newHeight -= (int)((cropY + newHeight) - dstHeight);
}
int uiCropX = cropX;
int uiCropY = cropY;
int uiNewWidth = newWidth;
int uiNewHeight = newHeight;
if (crop)
{
itemPixelBuffer.Crop((ushort)uiCropX, (ushort)uiCropY, (ushort)uiNewWidth, (ushort)uiNewHeight);
}
// Blend the item pixel buffer with the text's color according its blending mode.
if (ColorBlendingMode.Multiply == itemLayout.ColorBlendingMode)
{
PixelBuffer buffer = new PixelBuffer((uint)uiNewWidth, (uint)uiNewHeight, itemPixelFormat);
IntPtr bufferIntPtr = buffer.GetBuffer();
IntPtr itemBufferIntPtr = itemPixelBuffer.GetBuffer();
uint bytesPerPixel = GetBytesPerPixel(itemPixelFormat);
uint size = (uint)(uiNewWidth * uiNewHeight * bytesPerPixel);
unsafe {
byte *bufferPtr = (byte *)bufferIntPtr.ToPointer();
byte *itemBufferPtr = (byte *)itemBufferIntPtr.ToPointer();
for (uint j = 0; j < size; j += bytesPerPixel)
{
*(bufferPtr + 0) = (byte)((*(itemBufferPtr + 0u)) * textParameters.TextColor.R);
*(bufferPtr + 1) = (byte)((*(itemBufferPtr + 1u)) * textParameters.TextColor.G);
*(bufferPtr + 2) = (byte)((*(itemBufferPtr + 2u)) * textParameters.TextColor.B);
*(bufferPtr + 3) = (byte)((*(itemBufferPtr + 3u)) * textParameters.TextColor.A);
itemBufferPtr += bytesPerPixel;
bufferPtr += bytesPerPixel;
}
}
itemPixelBuffer = buffer;
}
TextUtils.UpdateBuffer(itemPixelBuffer, pixelBuffer, (uint)layoutX, (uint)layoutY, true);
}
PixelData pixelData = PixelBuffer.Convert(pixelBuffer);
Texture texture = new Texture(TextureType.TEXTURE_2D,
pixelData.GetPixelFormat(),
pixelData.GetWidth(),
pixelData.GetHeight());
texture.Upload(pixelData);
TextureSet textureSet = new TextureSet();
textureSet.SetTexture(0u, texture);
return(textureSet);
}
protected virtual void WithShadowsConfigurer(AnimationUtilities.SkinnedEffect effect, RendererParameters instance, object[] optionalParameters)
{
}
protected override void NormalDepthConfigurer(AnimationUtilities.SkinnedEffect effect, RendererParameters instance, object[] optionalParameters)
{
effect.CurrentTechnique = effect.Techniques["NormalDepthShade"];
}
public void AddInstance(RendererParameters instance)
{
mInstances.Enqueue(instance);
}
protected override void WithShadowsConfigurer(AnimationUtilities.SkinnedEffect effect, RendererParameters instance, object[] optionalParameters)
{
CascadedShadowMap shadowMap = optionalParameters[0] as CascadedShadowMap;
Light light = optionalParameters[1] as Light;
effect.CurrentTechnique = effect.Techniques["CelShadeWithShadows"];
effect.Parameters["ShadowMap"].SetValue(shadowMap.Buffer);
effect.Parameters["xLightView"].SetValue(shadowMap.LightView);
effect.Parameters["xLightProjections"].SetValue(shadowMap.LightProjections);
effect.Parameters["xVisualizeCascades"].SetValue(shadowMap.VisualizeCascades);
effect.Parameters["xCascadeCount"].SetValue(shadowMap.CascadeCount);
effect.Parameters["xCascadeBufferBounds"].SetValue(shadowMap.CascadeBounds);
effect.Parameters["xCascadeColors"].SetValue(shadowMap.CascadeColors);
effect.Parameters["xDirLightDirection"].SetValue(light.Direction);
effect.Parameters["xDirLightDiffuseColor"].SetValue(light.DiffuseColor);
effect.Parameters["xDirLightSpecularColor"].SetValue(light.SpecularColor);
effect.Parameters["xDirLightAmbientColor"].SetValue(light.AmbientColor);
effect.SpecularColor = new Vector3(0.25f);
effect.SpecularPower = 16;
}
protected override void NoShadeConfigurer(AnimationUtilities.SkinnedEffect effect, RendererParameters instance, object[] optionalParameters)
{
effect.Parameters["xTextureTransformation"].SetValue((instance as TransparentModelParameters).AnimationTransformation);
effect.CurrentTechnique = effect.Techniques["NoShade"];
}
protected void RenderUI(Matrix view, Matrix projection, RendererParameters instance)
{
DrawGeometry(view, projection, null, mUIConfigurer, instance);
}
protected override void PickingConfigurer(AnimationUtilities.SkinnedEffect effect, RendererParameters instance, object[] optionalParameters)
{
effect.CurrentTechnique = effect.Techniques["PickingShade"];
effect.Parameters["xPickingIndex"].SetValue(new Vector4(0, 0, 0, 0));
}
/// <summary>
/// Draws all charts inside the ChartFrame.
/// </summary>
public void Draw(XGraphics gfx)
{
// Draw frame of ChartFrame. First shadow frame.
int dx = 5;
int dy = 5;
gfx.DrawRoundedRectangle(XBrushes.Gainsboro,
this.location.X + dx, this.location.Y + dy,
this.size.Width, this.size.Height, 20, 20);
XRect chartRect = new XRect(this.location.X, this.location.Y, this.size.Width, this.size.Height);
XLinearGradientBrush brush = new XLinearGradientBrush(chartRect, XColor.FromArgb(0xFFD0DEEF), XColors.White,
XLinearGradientMode.Vertical);
XPen penBorder = new XPen(XColors.SteelBlue, 2.5);
gfx.DrawRoundedRectangle(penBorder, brush,
this.location.X, this.location.Y, this.size.Width, this.size.Height,
15, 15);
XGraphicsState state = gfx.Save();
gfx.TranslateTransform(this.location.X, this.location.Y);
// Calculate rectangle for all charts. Y-Position will be moved for each chart.
int charts = this.chartList.Count;
uint dxChart = 20;
uint dyChart = 20;
uint dyBetweenCharts = 30;
XRect rect = new XRect(dxChart, dyChart,
this.size.Width - 2 * dxChart,
(this.size.Height - (charts - 1) * dyBetweenCharts - 2 * dyChart) / charts);
// draw each chart in list
foreach (Chart chart in this.chartList)
{
RendererParameters parms = new RendererParameters(gfx, rect);
parms.DrawingItem = chart;
ChartRenderer renderer = GetChartRenderer(chart, parms);
renderer.Init();
renderer.Format();
renderer.Draw();
rect.Y += rect.Height + dyBetweenCharts;
}
gfx.Restore(state);
// // Calculate rectangle for all charts. Y-Position will be moved for each chart.
// int charts = this.chartList.Count;
// uint dxChart = 0;
// uint dyChart = 0;
// uint dyBetweenCharts = 0;
// XRect rect = new XRect(dxChart, dyChart,
// this.size.Width - 2 * dxChart,
// (this.size.Height - (charts - 1) * dyBetweenCharts - 2 * dyChart) / charts);
//
// // draw each chart in list
// foreach (Chart chart in this.chartList)
// {
// RendererParameters parms = new RendererParameters(gfx, rect);
// parms.DrawingItem = chart;
//
// ChartRenderer renderer = GetChartRenderer(chart, parms);
// renderer.Init();
// renderer.Format();
// renderer.Draw();
//
// rect.Y += rect.Height + dyBetweenCharts;
// }
}
protected void RenderWithoutShadows(Matrix view, Matrix projection, Light light, RendererParameters instance)
{
DrawGeometry(view, projection, new object[] { light }, mWithoutShadowsConfigurer, instance);
}
/// <summary>
/// Initializes a new instance of the XAxisRenderer class with the specified renderer parameters.
/// </summary>
internal XAxisRenderer(RendererParameters parms)
: base(parms)
{ }
protected void RenderWithShadows(CascadedShadowMap shadowMap, Matrix view, Matrix projection, Light light, RendererParameters instance)
{
DrawGeometry(view, projection, new object[] { shadowMap, light }, mWithShadowsConfigurer, instance);
}
