public override void Apply(Graphics graphics, Bitmap applyBitmap, Rectangle rect, RenderMode renderMode)
{
Rectangle applyRect = ImageHelper.CreateIntersectRectangle(applyBitmap.Size, rect, Invert);
if (applyRect.Width == 0 || applyRect.Height == 0)
{
// nothing to do
return;
}
GraphicsState state = graphics.Save();
if (Invert)
{
graphics.SetClip(applyRect);
graphics.ExcludeClip(rect);
}
ColorMatrix grayscaleMatrix = new ColorMatrix(new[] {
new[] {.3f, .3f, .3f, 0, 0},
new[] {.59f, .59f, .59f, 0, 0},
new[] {.11f, .11f, .11f, 0, 0},
new float[] {0, 0, 0, 1, 0},
new float[] {0, 0, 0, 0, 1}
});
using (ImageAttributes ia = new ImageAttributes())
{
ia.SetColorMatrix(grayscaleMatrix);
graphics.DrawImage(applyBitmap, applyRect, applyRect.X, applyRect.Y, applyRect.Width, applyRect.Height, GraphicsUnit.Pixel, ia);
}
graphics.Restore(state);
}
public unsafe override void Apply(Graphics graphics, Bitmap applyBitmap, Rectangle rect, RenderMode renderMode)
{
int blurRadius = GetFieldValueAsInt(FieldType.BLUR_RADIUS);
double previewQuality = GetFieldValueAsDouble(FieldType.PREVIEW_QUALITY);
Rectangle applyRect = ImageHelper.CreateIntersectRectangle(applyBitmap.Size, rect, Invert);
if (applyRect.Width == 0 || applyRect.Height == 0)
{
return;
}
GraphicsState state = graphics.Save();
if (Invert)
{
graphics.SetClip(applyRect);
graphics.ExcludeClip(rect);
}
if (GDIplus.IsBlurPossible(blurRadius))
{
GDIplus.DrawWithBlur(graphics, applyBitmap, applyRect, null, null, blurRadius, false);
}
else
{
using (IFastBitmap fastBitmap = FastBitmap.CreateCloneOf(applyBitmap, applyRect))
{
ImageHelper.ApplyBoxBlur(fastBitmap, blurRadius);
fastBitmap.DrawTo(graphics, applyRect);
}
}
graphics.Restore(state);
return;
}
public override void Draw(Graphics graphics, RenderMode rm) {
int lineThickness = GetFieldValueAsInt(FieldType.LINE_THICKNESS);
Color lineColor = GetFieldValueAsColor(FieldType.LINE_COLOR);
bool shadow = GetFieldValueAsBool(FieldType.SHADOW);
bool lineVisible = (lineThickness > 0 && Colors.IsVisible(lineColor));
if (lineVisible) {
graphics.SmoothingMode = SmoothingMode.HighSpeed;
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
graphics.CompositingQuality = CompositingQuality.HighQuality;
graphics.PixelOffsetMode = PixelOffsetMode.None;
//draw shadow first
if (shadow) {
int basealpha = 100;
int alpha = basealpha;
int steps = 5;
int currentStep = lineVisible ? 1 : 0;
while (currentStep <= steps) {
using (Pen shadowPen = new Pen(Color.FromArgb(alpha, 100, 100, 100), lineThickness)) {
Rectangle shadowRect = GuiRectangle.GetGuiRectangle(Left + currentStep, Top + currentStep, Width, Height);
graphics.DrawRectangle(shadowPen, shadowRect);
currentStep++;
alpha = alpha - (basealpha / steps);
}
}
}
Rectangle rect = GuiRectangle.GetGuiRectangle(Left, Top, Width, Height);
if (lineThickness > 0) {
using (Pen pen = new Pen(lineColor, lineThickness)) {
graphics.DrawRectangle(pen, rect);
}
}
}
}
/// <summary>
/// Implements the Apply code for the Brightness Filet
/// </summary>
/// <param name="graphics"></param>
/// <param name="applyBitmap"></param>
/// <param name="rect"></param>
/// <param name="renderMode"></param>
public override void Apply(Graphics graphics, Bitmap applyBitmap, Rectangle rect, RenderMode renderMode) {
Rectangle applyRect = ImageHelper.CreateIntersectRectangle(applyBitmap.Size, rect, Invert);
if (applyRect.Width == 0 || applyRect.Height == 0) {
// nothing to do
return;
}
GraphicsState state = graphics.Save();
if (Invert) {
graphics.SetClip(applyRect);
graphics.ExcludeClip(rect);
}
using (IFastBitmap fastBitmap = FastBitmap.CreateCloneOf(applyBitmap, applyRect)) {
Color highlightColor = GetFieldValueAsColor(FieldType.FILL_COLOR);
for (int y = fastBitmap.Top; y < fastBitmap.Bottom; y++) {
for (int x = fastBitmap.Left; x < fastBitmap.Right; x++) {
Color color = fastBitmap.GetColorAt(x, y);
color = Color.FromArgb(color.A, Math.Min(highlightColor.R, color.R), Math.Min(highlightColor.G, color.G), Math.Min(highlightColor.B, color.B));
fastBitmap.SetColorAt(x, y, color);
}
}
fastBitmap.DrawTo(graphics, applyRect.Location);
}
graphics.Restore(state);
}
void IRenderable.Render(OpenGL gl, RenderMode renderMode)
{
if (positionBuffer != null && colorBuffer != null && radiusBuffer != null)
{
if (this.shaderProgram == null)
{
this.shaderProgram = InitShader(gl, renderMode);
}
if (this.vertexArrayObject == null)
{
CreateVertexArrayObject(gl, renderMode);
}
BeforeRendering(gl, renderMode);
if (this.RenderGrid && this.vertexArrayObject != null)
{
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(SharpGL.Enumerations.BlendingSourceFactor.SourceAlpha, SharpGL.Enumerations.BlendingDestinationFactor.OneMinusSourceAlpha);
gl.BindVertexArray(this.vertexArrayObject[0]);
gl.DrawArrays(OpenGL.GL_POINTS, 0, count);
gl.BindVertexArray(0);
gl.Disable(OpenGL.GL_BLEND);
}
AfterRendering(gl, renderMode);
}
}
public void Init(RenderMode renderMode)
{
if (renderMode == RenderMode.Render2D)
{
GL.MatrixMode(MatrixMode.Projection);
var aspectRatio = (float)form.ClientSize.Width / form.ClientSize.Height;
GL.LoadIdentity();
GL.Scale(1, aspectRatio, 1);
GL.MatrixMode(MatrixMode.Modelview);
}
else
{
GL.Enable(EnableCap.DepthTest);
GL.ShadeModel(ShadingModel.Smooth);
GL.Enable(EnableCap.Lighting);
GL.Light(LightName.Light0, LightParameter.Ambient, new[] { .2f, .2f, .2f, 1.0f });
GL.Light(LightName.Light0, LightParameter.Diffuse, new[] { 1, 1, 1, 1.0f });
GL.Light(LightName.Light0, LightParameter.Position,
new[] { Common.LightPosition.x, Common.LightPosition.y, Common.LightPosition.z });
GL.Enable(EnableCap.Light0);
GL.MatrixMode(MatrixMode.Projection);
Common.ProjectionMatrix = Matrix4.CreatePerspectiveFieldOfView(Common.FieldOfView,
form.ClientSize.Width / (float)form.ClientSize.Height, Common.NearPlane, Common.FarPlane);
GL.LoadMatrix(ref Common.ProjectionMatrix);
GL.MatrixMode(MatrixMode.Modelview);
Common.ViewMatrix = Matrix4.LookAt(Common.CameraPosition.x, Common.CameraPosition.y,
Common.CameraPosition.z, 0, 0, 4, 0, 0, 1);
GL.LoadMatrix(ref Common.ViewMatrix);
}
}
public override void Apply(Graphics graphics, Bitmap applyBitmap, Rectangle rect, RenderMode renderMode)
{
Rectangle applyRect = ImageHelper.CreateIntersectRectangle(applyBitmap.Size, rect, Invert);
if (applyRect.Width == 0 || applyRect.Height == 0)
{
// nothing to do
return;
}
int magnificationFactor = GetFieldValueAsInt(FieldType.MAGNIFICATION_FACTOR);
GraphicsState state = graphics.Save();
if (Invert)
{
graphics.SetClip(applyRect);
graphics.ExcludeClip(rect);
}
graphics.SmoothingMode = SmoothingMode.None;
graphics.InterpolationMode = InterpolationMode.NearestNeighbor;
graphics.CompositingQuality = CompositingQuality.HighQuality;
graphics.PixelOffsetMode = PixelOffsetMode.None;
int halfWidth = rect.Width / 2;
int halfHeight = rect.Height / 2;
int newWidth = rect.Width / magnificationFactor;
int newHeight = rect.Height / magnificationFactor;
Rectangle source = new Rectangle(rect.X + halfWidth - (newWidth / 2), rect.Y + halfHeight - (newHeight / 2), newWidth, newHeight);
graphics.DrawImage(applyBitmap, rect, source, GraphicsUnit.Pixel);
graphics.Restore(state);
}
/// <summary>
/// Render to the provided instance of OpenGL.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="renderMode">The render mode.</param>
public override void Render(OpenGL gl, RenderMode renderMode)
{
// Create the evaluator.
gl.Map1(OpenGL.GL_MAP1_VERTEX_3,// Use and produce 3D points.
0, // Low order value of 'u'.
1, // High order value of 'u'.
3, // Size (bytes) of a control point.
ControlPoints.Width, // Order (i.e degree plus one).
ControlPoints.ToFloatArray()); // The control points.
// Enable the type of evaluator we wish to use.
gl.Enable(OpenGL.GL_MAP1_VERTEX_3);
// Beging drawing a line strip.
gl.Begin(OpenGL.GL_LINE_STRIP);
// Now draw it.
for (int i = 0; i <= segments; i++)
gl.EvalCoord1((float)i / segments);
gl.End();
// Draw the control points.
ControlPoints.Draw(gl, DrawControlPoints, DrawControlGrid);
}
public Tile(Image image, TileCoordinate tile, RenderMode mode)
{
this.tile = tile;
if(image != null)
{
this.mode = mode;
switch(mode)
{
case RenderMode.GDI:
{
using(Bitmap bitmap = new Bitmap(image))
{
this.ptrHbitmap = bitmap.GetHbitmap();
}
}
break;
case RenderMode.GDI_PLUS:
{
this.image = image;
}
break;
}
}
}
public static Canvas GetCanvas(RenderMode renderMode) {
Canvas canvas = null;
Canvas[] sceneCanvases = GameObject.FindObjectsOfType<Canvas>();
for (int i = 0; i < sceneCanvases.Length; i++) {
if (sceneCanvases[i].renderMode == renderMode) {
canvas = sceneCanvases[i];
break;
}
}
if (canvas == null) {
GameObject canvasGO = new GameObject("Canvas");
canvasGO.layer = LayerMask.NameToLayer("UI");
canvasGO.AddComponent<GraphicRaycaster>();
canvas = canvasGO.GetComponent<Canvas>();
canvas.renderMode = renderMode;
if (GameObject.FindObjectOfType<EventSystem>() == null) {
GameObject eventSystemGO = new GameObject("EventSystem");
eventSystemGO.AddComponent<EventSystem>();
#if !UNITY_EDITOR && (UNITY_ANDROID || UNITY_IPHONE)
eventSystemGO.AddComponent<TouchInputModule>();
#else
eventSystemGO.AddComponent<StandaloneInputModule>();
#endif
}
}
return canvas;
}
private static void Generate(string xamlFile, string outputFile, RenderMode renderMode, string desiredNamespace, string defaultAssembly)
{
string xaml = string.Empty;
using (TextReader tr = File.OpenText(xamlFile))
{
xaml = tr.ReadToEnd();
}
if (!string.IsNullOrEmpty(defaultAssembly))
xaml = Regex.Replace(xaml,
@"xmlns(:\w+)?=\""clr-namespace:([.\w]+)(;assembly=)?\""",
$@"xmlns$1=""clr-namespace:$2;assembly=" + defaultAssembly + '"');
UserInterfaceGenerator generator = new UserInterfaceGenerator();
string generatedCode = string.Empty;
try
{
generatedCode = generator.GenerateCode(xamlFile, xaml, renderMode, desiredNamespace);
}
catch (Exception ex)
{
generatedCode = "#error " + ex.Message;
throw;
}
finally
{
using (StreamWriter outfile = new StreamWriter(outputFile))
{
outfile.Write(generatedCode);
}
}
}
public ActivityButton()
{
this.Image = new Uri("pack://application:,,,/Images/activity.PNG");
this.Text = "Default";
this.RenderMode = RenderMode.ImageAndText;
this.VerticalAlignment = System.Windows.VerticalAlignment.Center;
}
/// <summary>
/// This allows another container to draw an ellipse
/// </summary>
/// <param name="caller"></param>
/// <param name="graphics"></param>
/// <param name="renderMode"></param>
public static void DrawEllipse(Rectangle rect, Graphics graphics, RenderMode renderMode, int lineThickness, Color lineColor, Color fillColor, bool shadow) {
bool lineVisible = (lineThickness > 0 && Colors.IsVisible(lineColor));
// draw shadow before anything else
if (shadow && (lineVisible || Colors.IsVisible(fillColor))) {
int basealpha = 100;
int alpha = basealpha;
int steps = 5;
int currentStep = lineVisible ? 1 : 0;
while (currentStep <= steps) {
using (Pen shadowPen = new Pen(Color.FromArgb(alpha, 100, 100, 100))) {
shadowPen.Width = lineVisible ? lineThickness : 1;
Rectangle shadowRect = GuiRectangle.GetGuiRectangle(rect.Left + currentStep, rect.Top + currentStep, rect.Width, rect.Height);
graphics.DrawEllipse(shadowPen, shadowRect);
currentStep++;
alpha = alpha - basealpha / steps;
}
}
}
//draw the original shape
if (Colors.IsVisible(fillColor)) {
using (Brush brush = new SolidBrush(fillColor)) {
graphics.FillEllipse(brush, rect);
}
}
if (lineVisible) {
using (Pen pen = new Pen(lineColor, lineThickness)) {
graphics.DrawEllipse(pen, rect);
}
}
}
public ActivityButton(Uri img, string text)
{
this.Image = img;
this.Text = text;
this.RenderMode = RenderMode.ImageAndText;
this.VerticalAlignment = System.Windows.VerticalAlignment.Center;
}
public override void Draw(Graphics g, RenderMode rm)
{
Rectangle rect = GuiRectangle.GetGuiRectangle(this.Left, this.Top, this.Width, this.Height);
g.FillRectangle(GetBrush(rect), rect);
Pen pen = new Pen(foreColor) { Width = thickness };
g.DrawRectangle(pen, rect);
}
public override void Draw(Graphics g, RenderMode rm)
{
g.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
Rectangle rect = GuiRectangle.GetGuiRectangle(this.Left, this.Top, this.Width, this.Height);
if (Selected && rm.Equals(RenderMode.EDIT)) DrawSelectionBorder(g, rect);
Brush fontBrush = new SolidBrush(foreColor);
g.DrawString(childLabel.Text, childLabel.Font, fontBrush, rect);
}
public override void Draw(Graphics g, RenderMode rm)
{
g.SmoothingMode = SmoothingMode.HighQuality;
Rectangle rect = GuiRectangle.GetGuiRectangle(this.Left, this.Top, this.Width, this.Height);
g.FillEllipse(GetBrush(rect), rect);
Pen pen = new Pen(foreColor) { Width = thickness };
g.DrawEllipse(pen, rect);
}
/// <summary>
/// Render to the provided instance of OpenGL.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="renderMode">The render mode.</param>
public override void Render(OpenGL gl, RenderMode renderMode)
{
// Call the base.
base.Render(gl, renderMode);
// Draw a quadric with the current settings.
gl.Cylinder(glQuadric, baseRadius, topRadius, height, slices, stacks);
}
/// <summary>
/// Render to the provided instance of OpenGL.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="renderMode">The render mode.</param>
public virtual void Render(OpenGL gl, RenderMode renderMode)
{
// Set the quadric properties.
gl.QuadricDrawStyle(glQuadric, (uint)drawStyle);
gl.QuadricOrientation(glQuadric, (int)orientation);
gl.QuadricNormals(glQuadric, (uint)normals);
gl.QuadricTexture(glQuadric, textureCoords ? 1 : 0);
}
/// <summary>
/// Render to the provided instance of OpenGL.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="renderMode">The render mode.</param>
public override void Render(OpenGL gl, RenderMode renderMode)
{
// Call the base.
base.Render(gl, renderMode);
// Draw a sphere with the current settings.
gl.Sphere(glQuadric, radius, slices, stacks);
}
public override void Draw(Graphics graphics, RenderMode rm) {
if (icon != null) {
graphics.SmoothingMode = SmoothingMode.HighQuality;
graphics.InterpolationMode = InterpolationMode.NearestNeighbor;
graphics.CompositingQuality = CompositingQuality.Default;
graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
graphics.DrawIcon(icon, Bounds);
}
}
public override void Reset()
{
cursorTexture = null;
hotSpot = new FsmVector2 { UseVariable = true };
renderMode = RenderMode.Auto;
lockMode = CurState.None;
hideCursor = true;
}
/// <summary>
/// Render to the provided instance of OpenGL.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="renderMode">The render mode.</param>
public override void Render(OpenGL gl, RenderMode renderMode)
{
// Call the base.
base.Render(gl, renderMode);
// Draw a quadric with the current settings.
gl.PartialDisk(glQuadric, innerRadius, outerRadius,
slices, loops, startAngle, sweepAngle);
}
public override void Draw(Graphics graphics, RenderMode rm) {
int lineThickness = GetFieldValueAsInt(FieldType.LINE_THICKNESS);
Color lineColor = GetFieldValueAsColor(FieldType.LINE_COLOR);
Color fillColor = GetFieldValueAsColor(FieldType.FILL_COLOR);
bool shadow = GetFieldValueAsBool(FieldType.SHADOW);
Rectangle rect = GuiRectangle.GetGuiRectangle(Left, Top, Width, Height);
DrawRectangle(rect, graphics, rm, lineThickness, lineColor, fillColor, shadow);
}
public override void Draw(Graphics graphics, RenderMode rm) {
if (cursor == null) {
return;
}
graphics.SmoothingMode = SmoothingMode.HighQuality;
graphics.InterpolationMode = InterpolationMode.NearestNeighbor;
graphics.CompositingQuality = CompositingQuality.Default;
graphics.PixelOffsetMode = PixelOffsetMode.None;
cursor.DrawStretched(graphics, Bounds);
}
/// <summary>
/// Initializes a new instance of the <see cref="PdfContentWriter"/> class
/// for creating a content stream of the specified form.
/// </summary>
public PdfContentWriter(DocumentRenderingContext context, XForm form, RenderMode renderMode) // , XGraphics gfx, XGraphicsPdfPageOptions options)
{
this.context = context;
this.form = form;
this.contentStreamDictionary = form;
this.renderMode = renderMode;
//this.colorMode = page.document.Options.ColorMode;
//this.options = options;
this.content = new StringBuilder();
this.graphicsState = new PdfGraphicsState(this);
}
public void m000236(RenderMode p0)
{
RenderState renderState = c000074.GetGraphicsDevice().RenderState;
SamplerState state2 = c000074.GetGraphicsDevice().SamplerStates[0];
renderState.CullMode = CullMode.CullCounterClockwiseFace;
renderState.DepthBufferFunction = CompareFunction.Less;
renderState.DepthBufferEnable = true;
renderState.DepthBufferWriteEnable = true;
state2.AddressU = TextureAddressMode.Wrap;
state2.AddressV = TextureAddressMode.Wrap;
}
public unsafe override void Apply(Graphics graphics, Bitmap applyBitmap, Rectangle rect, RenderMode renderMode)
{
int blurRadius = GetFieldValueAsInt(FieldType.BLUR_RADIUS);
double previewQuality = GetFieldValueAsDouble(FieldType.PREVIEW_QUALITY);
Rectangle applyRect = ImageHelper.CreateIntersectRectangle(applyBitmap.Size, rect, Invert);
using (Bitmap blurImage = ImageHelper.CreateBlur(applyBitmap, applyRect, renderMode == RenderMode.EXPORT, blurRadius, previewQuality, Invert, parent.Bounds)) {
if (blurImage != null) {
graphics.DrawImageUnscaled(blurImage, applyRect.Location);
}
}
return;
}
public static Canvas CreateNewCanvas(string name, RenderMode renderMode = RenderMode.ScreenSpaceOverlay)
{
Canvas canvas = new GameObject(name).AddComponent<Canvas>();
canvas.gameObject.AddComponent<CanvasScaler>().uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
canvas.gameObject.GetComponent<CanvasScaler>().referenceResolution = new Vector2(1920, 1080);
canvas.renderMode = renderMode;
canvas.worldCamera = Camera.main;
canvas.planeDistance = 5;
return canvas;
}
private static bool RenderStatesDiffer(RenderState oldRenderState, RenderState newRenderState, RenderMode flag)
{
bool oldRenderStateNull = (oldRenderState == null);
bool newFlag = ((newRenderState.RenderMode & flag) != 0);
if (oldRenderStateNull)
return true;
bool oldFlag = ((oldRenderState.RenderMode & flag) != 0);
return oldFlag != newFlag;
}
protected void BeforeRendering(OpenGL gl, RenderMode renderMode)
{
IScientificCamera camera = this.camera;
if (camera != null)
{
if (camera.CameraType == CameraTypes.Perspecitive)
{
IPerspectiveViewCamera perspective = camera;
this.projectionMatrix = perspective.GetProjectionMat4();
this.viewMatrix = perspective.GetViewMat4();
}
else if (camera.CameraType == CameraTypes.Ortho)
{
IOrthoViewCamera ortho = camera;
this.projectionMatrix = ortho.GetProjectionMat4();
this.viewMatrix = ortho.GetViewMat4();
}
else
{
throw new NotImplementedException();
}
}
modelMatrix = mat4.identity();
ShaderProgram shaderProgram = this.shaderProgram;
// Bind the shader, set the matrices.
shaderProgram.Bind(gl);
shaderProgram.SetUniformMatrix4(gl, "projectionMatrix", projectionMatrix.to_array());
shaderProgram.SetUniformMatrix4(gl, "viewMatrix", viewMatrix.to_array());
shaderProgram.SetUniformMatrix4(gl, "modelMatrix", modelMatrix.to_array());
//gl.Enable(OpenGL.GL_POLYGON_SMOOTH);
//gl.Hint(OpenGL.GL_POLYGON_SMOOTH_HINT, OpenGL.GL_NICEST);
this.texture.Bind(gl);
shaderProgram.SetUniform1(gl, "tex", this.texture.TextureName);
shaderProgram.SetUniform1(gl, "brightness", this.Brightness);
}
public override void Draw(Graphics g, RenderMode rm)
{
int lineThickness = GetFieldValueAsInt(FieldType.LINE_THICKNESS);
Color lineColor = GetFieldValueAsColor(FieldType.LINE_COLOR);
bool shadow = GetFieldValueAsBool(FieldType.SHADOW);
bool lineVisible = (lineThickness > 0 && Colors.IsVisible(lineColor));
if (shadow && lineVisible)
{
//draw shadow first
int basealpha = 100;
int alpha = basealpha;
int steps = 5;
int currentStep = lineVisible ? 1 : 0;
while (currentStep <= steps)
{
using (Pen shadowPen = new Pen(Color.FromArgb(alpha, 100, 100, 100))) {
shadowPen.Width = lineVisible ? lineThickness : 1;
Rectangle shadowRect = GuiRectangle.GetGuiRectangle(
this.Left + currentStep,
this.Top + currentStep,
this.Width,
this.Height);
g.DrawRectangle(shadowPen, shadowRect);
currentStep++;
alpha = alpha - (basealpha / steps);
}
}
}
Rectangle rect = GuiRectangle.GetGuiRectangle(this.Left, this.Top, this.Width, this.Height);
using (Pen pen = new Pen(lineColor)) {
pen.Width = lineThickness;
if (pen.Width > 0)
{
g.DrawRectangle(pen, rect);
}
}
}
private uint _showTrisCount; //测试数据，记录当前显示的三角形数
public SoftRendererDemo()
{
//VectorMatrixTestCase.Test();
InitializeComponent();
try
{
System.Drawing.Image img = System.Drawing.Image.FromFile("../../Texture/texture.jpg");
_texture = new Bitmap(img, 256, 256);
}
catch (Exception)
{
_texture = new Bitmap(256, 256);
initTexture();
}
//
_currentMode = RenderMode.Textured;
_lightMode = LightMode.On;
_textureFilterMode = TextureFilterMode.Bilinear;
//
_frameBuff = new Bitmap(this.MaximumSize.Width, this.MaximumSize.Height);
_frameG = Graphics.FromImage(_frameBuff);
_zBuff = new float[this.MaximumSize.Height, this.MaximumSize.Width];
_ambientColor = new RenderData.Color(1f, 1f, 1f);
_mesh = new Mesh(CubeTestData.pointList, CubeTestData.indexs, CubeTestData.uvs, CubeTestData.vertColors, CubeTestData.norlmas, QuadTestData.mat);
//_mesh = new Mesh(QuadTestData.pointList, QuadTestData.indexs, QuadTestData.uvs, QuadTestData.vertColors, QuadTestData.norlmas, QuadTestData.mat); //打开注释可以切换mesh
//定义光照
_light = new Light(new Vector3D(50, 0, 0), new RenderData.Color(1, 1, 1));
//定义相机
_camera = new Camera(new Vector3D(0, 0, 0, 1), new Vector3D(0, 0, 1, 1), new Vector3D(0, 1, 0, 0), (float)System.Math.PI / 4, this.MaximumSize.Width / (float)this.MaximumSize.Height, 1f, 500f);
System.Timers.Timer mainTimer = new System.Timers.Timer(1000 / 60f);
mainTimer.Elapsed += new ElapsedEventHandler(Tick);
mainTimer.AutoReset = true;
mainTimer.Enabled = true;
mainTimer.Start();
//
}
public override void Draw(Graphics graphics, RenderMode rm)
{
graphics.SmoothingMode = SmoothingMode.HighQuality;
graphics.InterpolationMode = InterpolationMode.HighQualityBilinear;
graphics.CompositingQuality = CompositingQuality.HighQuality;
graphics.PixelOffsetMode = PixelOffsetMode.None;
int lineThickness = GetFieldValueAsInt(FieldType.LINE_THICKNESS);
Color lineColor = GetFieldValueAsColor(FieldType.LINE_COLOR);
bool shadow = GetFieldValueAsBool(FieldType.SHADOW);
if (lineThickness > 0)
{
if (shadow)
{
//draw shadow first
int basealpha = 100;
int alpha = basealpha;
int steps = 5;
int currentStep = 1;
while (currentStep <= steps)
{
using (Pen shadowCapPen = new Pen(Color.FromArgb(alpha, 100, 100, 100), lineThickness)) {
graphics.DrawLine(shadowCapPen,
Left + currentStep,
Top + currentStep,
Left + currentStep + Width,
Top + currentStep + Height);
currentStep++;
alpha = alpha - (basealpha / steps);
}
}
}
using (Pen pen = new Pen(lineColor, lineThickness)) {
graphics.DrawLine(pen, Left, Top, Left + Width, Top + Height);
}
}
}
/// <summary>
/// This allows another container to draw an ellipse
/// </summary>
/// <param name="caller"></param>
/// <param name="graphics"></param>
/// <param name="renderMode"></param>
public static void DrawEllipse(Rectangle rect, Graphics graphics, RenderMode renderMode, int lineThickness, Color lineColor, Color fillColor, bool shadow)
{
bool lineVisible = (lineThickness > 0 && Colors.IsVisible(lineColor));
// draw shadow before anything else
if (shadow && (lineVisible || Colors.IsVisible(fillColor)))
{
int basealpha = 100;
int alpha = basealpha;
int steps = 5;
int currentStep = lineVisible ? 1 : 0;
while (currentStep <= steps)
{
using (Pen shadowPen = new Pen(Color.FromArgb(alpha, 100, 100, 100)))
{
shadowPen.Width = lineVisible ? lineThickness : 1;
Rectangle shadowRect = GuiRectangle.GetGuiRectangle(rect.Left + currentStep, rect.Top + currentStep, rect.Width, rect.Height);
graphics.DrawEllipse(shadowPen, shadowRect);
currentStep++;
alpha = alpha - basealpha / steps;
}
}
}
//draw the original shape
if (Colors.IsVisible(fillColor))
{
using (Brush brush = new SolidBrush(fillColor))
{
graphics.FillEllipse(brush, rect);
}
}
if (lineVisible)
{
using (Pen pen = new Pen(lineColor, lineThickness))
{
graphics.DrawEllipse(pen, rect);
}
}
}
public override void OnInspectorGUI()
{
VolumeRenderedObject volrendObj = (VolumeRenderedObject)target;
RenderMode oldRenderMode = volrendObj.GetRenderMode();
RenderMode newRenderMode = (RenderMode)EditorGUILayout.EnumPopup("Render mode", oldRenderMode);
if (newRenderMode == RenderMode.IsosurfaceRendering)
{
Material mat = volrendObj.GetComponent <MeshRenderer>().sharedMaterial; // TODO
float minVal = mat.GetFloat("_MinVal");
float maxVal = mat.GetFloat("_MaxVal");
EditorGUILayout.MinMaxSlider("Visible value range", ref minVal, ref maxVal, 0.0f, 1.0f);
mat.SetFloat("_MinVal", minVal);
mat.SetFloat("_MaxVal", maxVal);
}
if (newRenderMode != oldRenderMode)
{
volrendObj.SetRenderMode(newRenderMode);
}
}
public WrapperStructPose(PoseMode poseMode,
Point <int> netInputSize,
Point <int> outputSize,
ScaleMode keyPointScale,
int gpuNumber,
int gpuNumberStart,
int scalesNumber,
float scaleGap,
RenderMode renderMode,
PoseModel poseModel,
bool blendOriginalFrame,
float alphaKeyPoint,
float alphaHeatMap,
int defaultPartToRender,
string modelFolder,
IEnumerable <HeatMapType> heatMapTypes,
ScaleMode heatMapScale,
bool addPartCandidates) :
this(poseMode,
netInputSize,
outputSize,
keyPointScale,
gpuNumber,
gpuNumberStart,
scalesNumber,
scaleGap,
renderMode,
poseModel,
blendOriginalFrame,
alphaKeyPoint,
alphaHeatMap,
defaultPartToRender,
modelFolder,
heatMapTypes,
heatMapScale,
addPartCandidates,
0.05f)
{
}
protected override void OnRenderNext(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode)
{
base.OnRenderNext(defaultTokenWs, parent, pattern, ref mode);
var tokenWs = GetTokenWhitespace(defaultTokenWs);
if (NeedsWhitespaceGroup(tokenWs, mode))
{
pattern.Append(")");
}
if (Expr != null)
{
if (!mode.HasFlag(RenderMode.Assert) && !string.IsNullOrEmpty(Id))
{
pattern.AppendFormat("(?<{0}>", CaptureId);
}
else
{
pattern.Append("(?:");
}
}
}
/// <summary>
/// This allows another container to draw an ellipse
/// </summary>
/// <param name="rect"></param>
/// <param name="graphics"></param>
/// <param name="renderMode"></param>
/// <param name="lineThickness"></param>
/// <param name="lineColor"></param>
/// <param name="fillColor"></param>
/// <param name="shadow"></param>
public static void DrawEllipse(NativeRect rect, Graphics graphics, RenderMode renderMode, int lineThickness, Color lineColor, Color fillColor, bool shadow)
{
var lineVisible = lineThickness > 0 && Colors.IsVisible(lineColor);
// draw shadow before anything else
if (shadow && (lineVisible || Colors.IsVisible(fillColor)))
{
var basealpha = 100;
var alpha = basealpha;
var steps = 5;
var currentStep = lineVisible ? 1 : 0;
while (currentStep <= steps)
{
using (var shadowPen = new Pen(Color.FromArgb(alpha, 100, 100, 100)))
{
shadowPen.Width = lineVisible ? lineThickness : 1;
var shadowRect = new NativeRect(rect.Left + currentStep, rect.Top + currentStep, rect.Width, rect.Height).Normalize();
graphics.DrawEllipse(shadowPen, shadowRect);
currentStep++;
alpha = alpha - basealpha / steps;
}
}
}
//draw the original shape
if (Colors.IsVisible(fillColor))
{
using (Brush brush = new SolidBrush(fillColor))
{
graphics.FillEllipse(brush, rect);
}
}
if (lineVisible)
{
using (var pen = new Pen(lineColor, lineThickness))
{
graphics.DrawEllipse(pen, rect);
}
}
}
public Canvas GetCanvasByMode(RenderMode mode, bool createIsNot = true)
{
Canvas c = mCanvas[(int)mode];
if (c == null && createIsNot)
{
GameObject obj = new GameObject();
c = obj.AddComponent <Canvas>();
c.sortingOrder = MaxSortOrder + 1;
obj.name = "Canvas_s" + mode.ToString();
obj.AddComponent <CanvasScaler>();
obj.AddComponent <GraphicRaycaster>();
obj.transform.SetParent(transform);
obj.layer = LayerMask.NameToLayer("UI");
c.renderMode = mode;
//if(RenderMode.ScreenSpaceOverlay == mode)
//{
// mDarkMask = getDarkMask(c);
//}
if (RenderMode.ScreenSpaceCamera == mode)
{
//GameObject cameraObj = new GameObject();
Camera _camera = obj.AddComponent <Camera>();
_camera.clearFlags = CameraClearFlags.Depth;
_camera.nearClipPlane = 0.1f;
_camera.farClipPlane = 200f;
//_camera.name = "SSCamera";
_camera.cullingMask = 1 << LayerMask.NameToLayer("UI");
_camera.orthographic = true;
//_camera.transform.LookAt(_camera.transform.position + Vector3.forward, Vector3.up);
//cameraObj.transform.SetParent(obj.transform, false);
c.worldCamera = _camera;
mDarkMask = _getDarkMask(c);
}
SetCanvasByMode(c);
//mCanvas[(int)mode] = c;
}
return(c);
}
protected override void OnRenderEnd(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode, Stack <Token> tokenStack)
{
base.OnRenderEnd(defaultTokenWs, parent, pattern, ref mode, tokenStack);
if (ExprNeedsGroup)
{
pattern.Append(")");
}
if (AtLeast == 0 && AtMost == 1)
{
pattern.Append("?");
}
else if (AtLeast == 0 && AtMost == int.MaxValue)
{
pattern.Append("*");
}
else if (AtLeast == 1 && AtMost == int.MaxValue)
{
pattern.Append("+");
}
else if (AtLeast == AtMost)
{
pattern.AppendFormat("{{{0}}}", AtLeast);
}
else if (AtMost == int.MaxValue)
{
pattern.AppendFormat("{{{0},}}", AtLeast);
}
else if (AtLeast == 0)
{
pattern.AppendFormat("{{,{0}}}", AtMost);
}
else
{
pattern.AppendFormat("{{{0},{1}}}", AtLeast, AtMost);
}
}
private List <List <Linker.Container> > GetNodes(RenderMode mode, int depth)
{
switch (mode)
{
case RenderMode.SIBLINGS:
return(GetAllSiblings(depth));
case RenderMode.LEVELS:
if (depth == 1)
{
List <List <Linker.Container> > list = new List <List <Linker.Container> >();
list.Add(GetNextLevel());
return(list);
}
return(GetAllLevels(depth));
default:
Debug.Log("Wrong mode.");
break;
}
return(null);
}
void HandleRotate(RenderMode renderMode, Canvas canvas)
{
isDirty = true;
Vector2 direction = Input.mousePosition - transform.position;
if (renderMode == RenderMode.ScreenSpaceCamera)
{
direction = (Vector2)Input.mousePosition - RectTransformUtility.WorldToScreenPoint(canvas.worldCamera, transform.position);
}
var angle = Mathf.Atan2(direction.y, direction.x) * Mathf.Rad2Deg;
var handleDir = rotateHandle.transform.localPosition;
var handleAngle = Mathf.Atan2(handleDir.y, handleDir.x) * Mathf.Rad2Deg;
transform.rotation = Quaternion.AngleAxis(angle - handleAngle, Vector3.forward);
if (OnRotate != null)
{
OnRotate();
}
}
public virtual void DrawContent(Graphics graphics, Bitmap bmp, RenderMode renderMode, Rectangle clipRectangle)
{
if (Children.Count > 0)
{
if (Status != EditStatus.IDLE)
{
DrawSelectionBorder(graphics, Bounds);
}
else
{
if (clipRectangle.Width != 0 && clipRectangle.Height != 0)
{
foreach (IFilter filter in Filters)
{
if (filter.Invert)
{
filter.Apply(graphics, bmp, Bounds, renderMode);
}
else
{
Rectangle drawingRect = new Rectangle(Bounds.Location, Bounds.Size);
drawingRect.Intersect(clipRectangle);
if (filter is MagnifierFilter)
{
// quick&dirty bugfix, because MagnifierFilter behaves differently when drawn only partially
// what we should actually do to resolve this is add a better magnifier which is not that special
filter.Apply(graphics, bmp, Bounds, renderMode);
}
else
{
filter.Apply(graphics, bmp, drawingRect, renderMode);
}
}
}
}
}
}
Draw(graphics, renderMode);
}
public override void Draw(Graphics g, RenderMode rm)
{
if (_parent == null)
{
return;
}
using (Brush cropBrush = new SolidBrush(Color.FromArgb(100, 150, 150, 100))) {
Rectangle cropRectangle = GuiRectangle.GetGuiRectangle(Left, Top, Width, Height);
Rectangle selectionRect = new Rectangle(cropRectangle.Left - 1, cropRectangle.Top - 1, cropRectangle.Width + 1, cropRectangle.Height + 1);
DrawSelectionBorder(g, selectionRect);
// top
g.FillRectangle(cropBrush, new Rectangle(0, 0, _parent.Width, cropRectangle.Top));
// left
g.FillRectangle(cropBrush, new Rectangle(0, cropRectangle.Top, cropRectangle.Left, cropRectangle.Height));
// right
g.FillRectangle(cropBrush, new Rectangle(cropRectangle.Left + cropRectangle.Width, cropRectangle.Top, _parent.Width - (cropRectangle.Left + cropRectangle.Width), cropRectangle.Height));
// bottom
g.FillRectangle(cropBrush, new Rectangle(0, cropRectangle.Top + cropRectangle.Height, _parent.Width, _parent.Height - (cropRectangle.Top + cropRectangle.Height)));
}
}
public override void Render(RenderTarget rt, RenderMode renderMode = RenderMode.BASE)
{
// Simulate
float dt = world.delta;
simulator.Update(dt);
Material m = GetMaterial(renderMode);
Texture tex = m.mainTexture;
IntRect subRect = new IntRect(0, 0, (int)tex.Size.X, (int)tex.Size.Y);
Vector2f scale = new Vector2f(1, 1);
foreach (Particle p in simulator.particles)
{
_batch.DrawCentered(p.position, subRect, p.color, scale);
}
_batch.Display(rt, new RenderStates(tex));
_batch.Flush();
}
// Use this for initialization
public void Awake()
{
instance = this;
if (!canvas)
{
canvas = GetComponentInParent <Canvas>();
canvas = canvas.rootCanvas;
}
_guiCamera = canvas.worldCamera;
guiMode = canvas.renderMode;
_rectTransform = GetComponent <RectTransform>();
SetNewDefaultPivot(_rectTransform.pivot);
canvasRectTransform = canvas.GetComponent <RectTransform>();
_layoutGroup = GetComponentInChildren <LayoutGroup>();
_text = GetComponentInChildren <Text>();
_inside = false;
this.gameObject.SetActive(false);
}
public override void Draw(Graphics graphics, RenderMode rm)
{
int lineThickness = GetFieldValueAsInt(FieldType.LINE_THICKNESS);
Color lineColor = GetFieldValueAsColor(FieldType.LINE_COLOR);
bool shadow = GetFieldValueAsBool(FieldType.SHADOW);
bool lineVisible = lineThickness > 0 && Colors.IsVisible(lineColor);
if (lineVisible)
{
graphics.SmoothingMode = SmoothingMode.HighSpeed;
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
graphics.CompositingQuality = CompositingQuality.HighQuality;
graphics.PixelOffsetMode = PixelOffsetMode.None;
//draw shadow first
if (shadow)
{
int basealpha = 100;
int alpha = basealpha;
int steps = 5;
int currentStep = lineVisible ? 1 : 0;
while (currentStep <= steps)
{
using (Pen shadowPen = new Pen(Color.FromArgb(alpha, 100, 100, 100), lineThickness)) {
Rectangle shadowRect = GuiRectangle.GetGuiRectangle(Left + currentStep, Top + currentStep, Width, Height);
graphics.DrawRectangle(shadowPen, shadowRect);
currentStep++;
alpha = alpha - basealpha / steps;
}
}
}
Rectangle rect = GuiRectangle.GetGuiRectangle(Left, Top, Width, Height);
if (lineThickness > 0)
{
using (Pen pen = new Pen(lineColor, lineThickness)) {
graphics.DrawRectangle(pen, rect);
}
}
}
}
/// <summary>
/// Render model with legacy opengl(glVertex() ...).
/// </summary>
/// <param name="model"></param>
/// <param name="gl"></param>
/// <param name="renderMode"></param>
public static void RenderLegacyOpenGL(this ScientificModel model, OpenGL gl, RenderMode renderMode)
{
if (model == null)
{
return;
}
if (model.VertexCount <= 0)
{
return;
}
float[] positions = model.Positions;
float[] colors = model.Colors;
gl.Begin(model.Mode);
for (int i = 0; i < model.VertexCount; i++)
{
gl.Color(colors[i * 3], colors[i * 3 + 1], colors[i * 3 + 2]);
gl.Vertex(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2]);
}
gl.End();
}
protected override IEnumerable <RegExpr> OnRender(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode)
{
base.OnRender(defaultTokenWs, parent, pattern, ref mode);
if (mode.HasFlag(RenderMode.Assert))
{
throw new NestedAssertException();
}
switch (Context)
{
case AssertLook.Ahead:
if (Negative)
{
pattern.Append("(?!");
}
else
{
pattern.Append("(?=");
}
break;
case AssertLook.Behind:
if (Negative)
{
pattern.Append("(?<!");
}
else
{
pattern.Append("(?<=");
}
break;
}
mode |= RenderMode.Assert;
return(Items(Expr));
}
// This updates the settings from configuration
public void UpdateConfiguration()
{
// Lookup settings
SpriteInfo ti = General.Map.Data.GetSpriteInfo(tileindex);
//mxd. Calculate size
var sprite = General.Map.Data.GetImageData(tileindex);
float xratio = RepeatX * ((FlatAligned && TrueCentered) ? 0.2f : 0.25f);
size = Math.Max((int)(sprite.Width * xratio) / 2, MINIMUM_SIZE);
fixedsize = ti.FixedSize;
// Color valid?
if ((ti.Color >= 0) && (ti.Color < ColorCollection.SpriteColorsCount))
{
// Apply color
color = General.Colors.Colors[ti.Color + General.Colors.SpriteColorsOffset];
}
else
{
// Unknown thing color
color = General.Colors.Colors[General.Colors.SpriteColorsOffset];
}
//mxd. Update display mode
if (CheckFlag(General.Map.FormatInterface.SpriteFlags.WallAligned))
{
displaymode = RenderMode.WALL;
}
else if (CheckFlag(General.Map.FormatInterface.SpriteFlags.FlatAligned))
{
displaymode = RenderMode.FLAT;
}
else
{
displaymode = RenderMode.BILLBOARD;
}
}
private ShaderProgram InitShader(OpenGL gl, RenderMode renderMode)
{
String vertexShaderSource = ManifestResourceLoader.LoadTextFile(@"Grids.PointGrid.vert");
String fragmentShaderSource = ManifestResourceLoader.LoadTextFile(@"Grids.PointGrid.frag");
var shaderProgram = new ShaderProgram();
shaderProgram.Create(gl, vertexShaderSource, fragmentShaderSource, null);
{
int location = shaderProgram.GetAttributeLocation(gl, in_Position);
if (location < 0)
{
throw new ArgumentException();
}
this.ATTRIB_INDEX_POSITION = (uint)location;
}
{
int location = shaderProgram.GetAttributeLocation(gl, in_uv);
if (location < 0)
{
throw new ArgumentException();
}
this.ATTRIB_INDEX_POSITION = (uint)location;
}
{
int location = shaderProgram.GetAttributeLocation(gl, in_radius);
if (location < 0)
{
throw new ArgumentException();
}
this.ATTRIB_INDEX_POSITION = (uint)location;
}
shaderProgram.AssertValid(gl);
return(shaderProgram);
}
private void CreateVertexArrayObject(OpenGL gl, RenderMode renderMode)
{
if (this.positionBuffer == null || this.colorBuffer == null || this.radiusBuffer == null)
{
return;
}
this.vertexArrayObject = new uint[1];
gl.GenVertexArrays(1, this.vertexArrayObject);
gl.BindVertexArray(this.vertexArrayObject[0]);
// prepare positions
{
int location = shaderProgram.GetAttributeLocation(gl, in_Position);
ATTRIB_INDEX_POSITION = (uint)location;
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, positionBuffer[0]);
gl.VertexAttribPointer(ATTRIB_INDEX_POSITION, 3, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(ATTRIB_INDEX_POSITION);
}
// prepare colors
{
int location = shaderProgram.GetAttributeLocation(gl, in_uv);
ATTRIB_INDEX_UV = (uint)location;
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, colorBuffer[0]);
gl.VertexAttribPointer(ATTRIB_INDEX_UV, 1, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(ATTRIB_INDEX_UV);
}
// prepare radius
{
int location = shaderProgram.GetAttributeLocation(gl, in_radius);
ATTRIB_INDEX_RADIUS = (uint)location;
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, radiusBuffer[0]);
gl.VertexAttribPointer(ATTRIB_INDEX_RADIUS, 1, OpenGL.GL_FLOAT, false, 0, IntPtr.Zero);
gl.EnableVertexAttribArray(ATTRIB_INDEX_RADIUS);
}
gl.BindVertexArray(0);
}
public WrapperStructPose(PoseMode poseMode,
Point <int> netInputSize,
Point <int> outputSize,
ScaleMode keyPointScale,
int gpuNumber,
int gpuNumberStart,
int scalesNumber,
float scaleGap,
RenderMode renderMode,
PoseModel poseModel) :
this(poseMode,
netInputSize,
outputSize,
keyPointScale,
gpuNumber,
gpuNumberStart,
scalesNumber,
scaleGap,
renderMode,
poseModel,
true)
{
}
/// <summary>
/// Updates timer and render mode
/// </summary>
void Update()
{
if (!IsSwitchingModes())
{
_timer = _secondsBetweenModes;
_switchTooltip.gameObject.SetActive(false);
return;
}
_timer -= Time.deltaTime;
if (_timer > 0)
{
_switchTooltip.gameObject.SetActive(true);
UpdateSwitchTooltip();
return;
}
_timer = _secondsBetweenModes;
_mode = GetNextRenderMode();
UpdateHandMeshingBehavior();
UpdateStatusText();
}
/// <summary>
/// Override the parent, calculate the label number, than draw
/// </summary>
/// <param name="graphics"></param>
/// <param name="rm"></param>
public override void Draw(Graphics graphics, RenderMode rm)
{
graphics.SmoothingMode = SmoothingMode.HighQuality;
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
graphics.CompositingQuality = CompositingQuality.HighQuality;
graphics.PixelOffsetMode = PixelOffsetMode.None;
graphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
string text = ((Surface)Parent).CountStepLabels(this).ToString();
Rectangle rect = GuiRectangle.GetGuiRectangle(Left, Top, Width, Height);
Color fillColor = GetFieldValueAsColor(FieldType.FILL_COLOR);
Color lineColor = GetFieldValueAsColor(FieldType.LINE_COLOR);
Color textColor = GetFieldValueAsColor(FieldType.TEXT_COLOR);
int lineThickness = GetFieldValueAsInt(FieldType.LINE_THICKNESS);
bool shadow = GetFieldValueAsBool(FieldType.SHADOW);
EllipseContainer.DrawEllipse(rect, graphics, rm, lineThickness, lineColor, fillColor, shadow);
using (FontFamily fam = new FontFamily(FontFamily.GenericSansSerif.Name)) {
using (Font font = new Font(fam, fontSize, FontStyle.Bold, GraphicsUnit.Pixel)) {
TextContainer.DrawText(graphics, rect, 0, textColor, false, _stringFormat, text, font);
}
}
}
/// <summary>
/// Render to the provided instance of OpenGL.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="renderMode">The render mode.</param>
public override void Render(OpenGL gl, RenderMode renderMode)
{
// Call the base.
base.Render(gl, renderMode);
// Begin drawing a NURBS curve.
gl.BeginCurve(nurbsRenderer);
// Draw the curve.
gl.NurbsCurve(nurbsRenderer, // The internal nurbs object.
knots.Length, // Number of knots.
knots, // The knots themselves.
3, // The size of a vertex.
ControlPoints.ToFloatArray(), // The control points.
ControlPoints.Width, // The order, i.e degree + 1.
OpenGL.GL_MAP1_VERTEX_3); // Type of data to generate.
// End the curve.
gl.EndCurve(nurbsRenderer);
// Draw the control points.
ControlPoints.Draw(gl, DrawControlPoints, DrawControlGrid);
}
private void SwitchVideoRendererButton(RenderMode mode)
{
switch (mode)
{
case RenderMode.NORMAL:
normalButton.SetEnable();
_180Button.SetDisable();
_360Button.SetDisable();
break;
case RenderMode._180:
normalButton.SetDisable();
_180Button.SetEnable();
_360Button.SetDisable();
break;
case RenderMode._360:
normalButton.SetDisable();
_180Button.SetDisable();
_360Button.SetEnable();
break;
}
}
void IRenderable.Render(OpenGL gl, RenderMode renderMode)
{
if (this.shaderProgram == null)
{
this.shaderProgram = InitShader(gl, renderMode);
}
if (this.matrixVertexArrayObject == null)
{
CreateVertexArrayObject(gl, renderMode);
}
if (this.fractionVertexArrayObject == null)
{
CreateFractionVertexArrayObject(gl, renderMode);
}
BeforeRendering(gl, renderMode);
DoRenderMatrix(gl, renderMode);
DoRenderFraction(gl, renderMode);
AfterRendering(gl, renderMode);
}
// Use this for initialization
public void Awake()
{
var _canvas = GetComponentInParent <Canvas>();
_guiCamera = _canvas.worldCamera;
_guiMode = _canvas.renderMode;
_rectTransform = GetComponent <RectTransform>();
_text = GetComponentInChildren <Text>();
_inside = false;
//size of the screen
// screenWidth = Screen.width;
// screenHeight = Screen.height;
xShift = 0f;
YShift = -30f;
// _xShifted = _yShifted = false;
this.gameObject.SetActive(false);
}