private static void LoadAndFuzzifyData(string fileName) { var developerParams = JObject.Parse(File.ReadAllText(fileName)); var legal = (double)developerParams["legal"]; Variables["Правовое состояние"] = LegalStateType.CreateVariable("Правовое состояние"); Variables["Правовое состояние"].Value = LegalStateType.GetValue(legal); var finance = (double)developerParams["finance"]; Variables["Финансовое состояние"] = FinanceStateType.CreateVariable("Финансовое состояние"); Variables["Финансовое состояние"].Value = FinanceStateType.GetValue(finance); var transparent = (double)developerParams["transparent"]; Variables["Прозрачность"] = TransparencyType.CreateVariable("Прозрачность"); Variables["Прозрачность"].Value = TransparencyType.GetValue(transparent); var honest = (double)developerParams["honest"]; Variables["Честность"] = HonestyType.CreateVariable("Честность"); Variables["Честность"].Value = HonestyType.GetValue(honest); var plan = (double)developerParams["plan"]; Variables["Соблюдение планов"] = PlanType.CreateVariable("Соблюдение планов"); Variables["Соблюдение планов"].Value = PlanType.GetValue(plan); }
/// <summary> /// Deserializes this SceneHints. /// </summary> /// <param name="input">Input to read from</param> public void Read(ISavableReader input) { _cullHint = input.ReadEnum <CullHint>(); _pickHint = input.ReadEnum <PickingHint>(); _lightHint = input.ReadEnum <LightCombineHint>(); _transHint = input.ReadEnum <TransparencyType>(); _bucketType = input.ReadEnum <RenderBucketType>(); _orthoOrder = input.ReadInt(); }
/// <summary> /// Creates a new scene hints object with the specified source hintable. /// </summary> /// <param name="source">Source hintable</param> public SceneHints(IHintable source) { _source = source; _cullHint = CullHint.Inherit; _lightHint = LightCombineHint.Inherit; _transHint = TransparencyType.Default; _pickHint = PickingHint.Inherit; _orthoOrder = 0; }
public ColorsAndFontChangedEventArgs(ThemeType themeSetting, TransparencyType transparencySetting, Color managedColor, string fontFamily, float fontSize, bool isFontBold, bool isFontItalic) { this.ThemeSetting = themeSetting; this.TransparencySetting = transparencySetting; this.ManagedColor = managedColor; this.FontFamily = fontFamily; this.FontSize = fontSize; this.IsFontBold = isFontBold; this.IsFontItalic = isFontItalic; }
/// <summary> /// Gets resulting color when blending two others. /// </summary> /// <param name="overlaying"> /// Foreground color. /// </param> /// <param name="underlaying"> /// Background color. /// </param> /// <param name="type"> /// Type of blending. /// </param> /// <returns>Blended color index.</returns> public byte GetResultingColorIndex(byte overlaying, byte underlaying, TransparencyType type) { switch (type) { case TransparencyType.None: return(overlaying); case TransparencyType.Dark: return(dark[underlaying * 256 + overlaying]); case TransparencyType.Main: return(main[underlaying * 256 + overlaying]); case TransparencyType.Light: return(light[underlaying * 256 + overlaying]); default: throw new ArgumentException("Unknown type.", "type"); } }
void Paint (WidgetType widgetType, Rectangle bounds, IDeviceContext dc, TransparencyType transparencyType, Color background, DeviceContextType deviceContextType, Rectangle clippingArea, Painter painter, Rectangle excludedArea) { Rectangle painted_area = Rectangle.Intersect (bounds, clippingArea); if (painted_area.Width == 0 || painted_area.Height == 0) return; painted_area.Offset (-bounds.X, -bounds.Y); excludedArea.Offset (-bounds.X, -bounds.Y); GdkDrawablePointer drawable = gdk_pixmap_new (IntPtr.Zero, bounds.Width, bounds.Height, 24); painter.AttachStyle (widgetType, drawable, this); GdkPixbufPointer pixbuf; IntPtr pixel_data; int rowstride; GdkGCPointer gc = gdk_gc_new (drawable); GdkColor color = new GdkColor (background); gdk_gc_set_rgb_fg_color (gc, ref color); Paint (drawable, gc, bounds, widgetType, out pixbuf, out pixel_data, out rowstride, painted_area, painter, excludedArea); GdkPixbufPointer white_pixbuf = IntPtr.Zero; IntPtr white_pixel_data = IntPtr.Zero; int white_rowstride = 0; GdkColor white_color = new GdkColor(); if (transparencyType == TransparencyType.Alpha) { white_color.red = guint16.MaxValue; white_color.green = guint16.MaxValue; white_color.blue = guint16.MaxValue; gdk_gc_set_rgb_fg_color (gc, ref white_color); Paint (drawable, gc, bounds, widgetType, out white_pixbuf, out white_pixel_data, out white_rowstride, painted_area, painter, excludedArea); } g_object_unref (gc); unsafe { byte* row = (byte*)pixel_data; byte* pixel; byte* white_row = (byte*)white_pixel_data; byte* white_pixel; for (int row_index = 0; row_index < painted_area.Height; row_index++) { pixel = row; white_pixel = white_row; for (int pixel_index = 0; pixel_index < painted_area.Width; pixel_index++) { const int GdkRedOffset = 0; const int GdkGreenOffset = 1; const int GdkBlueOffset = 2; const int BitmapAlphaOffset = 3; const int BitmapRedOffset = 2; const int BitmapBlueOffset = 0; switch (transparencyType) { case TransparencyType.Alpha: pixel [BitmapAlphaOffset] = (byte)(pixel [GdkRedOffset] - white_pixel [GdkRedOffset] + byte.MaxValue); break; case TransparencyType.Color: if ( pixel [GdkRedOffset] == background.R && pixel [GdkGreenOffset] == background.G && pixel [GdkBlueOffset] == background.B) { const int AlphaFullyTransparent = 0; pixel [BitmapAlphaOffset] = AlphaFullyTransparent; } break; } byte temporary = pixel [GdkRedOffset]; pixel [BitmapBlueOffset] = pixel [GdkBlueOffset]; pixel [BitmapRedOffset] = temporary; const int PixelSize = 4; pixel += PixelSize; white_pixel += PixelSize; } row += rowstride; white_row += white_rowstride; } } if (transparencyType == TransparencyType.Alpha) g_object_unref (white_pixbuf); g_object_unref (drawable); Bitmap bitmap = new Bitmap (painted_area.Width, painted_area.Height, rowstride, PixelFormat.Format32bppPArgb, pixel_data); Graphics g; bool graphics_is_from_hdc = false; switch (deviceContextType) { case DeviceContextType.Graphics: g = (Graphics)dc; break; case DeviceContextType.Native: g = Graphics.FromHdc (dc.GetHdc ()); break; default: g = dc as Graphics; if (g == null) { graphics_is_from_hdc = true; g = Graphics.FromHdc (dc.GetHdc ()); } else graphics_is_from_hdc = false; break; } painted_area.Offset (bounds.X, bounds.Y); g.DrawImage (bitmap, painted_area.Location); switch (deviceContextType) { case DeviceContextType.Graphics: break; case DeviceContextType.Native: g.Dispose (); dc.ReleaseHdc (); break; default: if (graphics_is_from_hdc) { g.Dispose (); dc.ReleaseHdc (); } break; } bitmap.Dispose (); g_object_unref (pixbuf); }
/// <summary> /// Called when deserializing /// </summary> /// <param name="info"></param> /// <param name="context"></param> protected BillboardGroupShape(SerializationInfo info, StreamingContext context) : base(info, context) { // if (SerializationHelper.HasElement(info,"_instances")) _instances = (BillboardInstance[])info.GetValue("_instances", typeof(BillboardInstance[])); _fBaseSizeX = info.GetSingle("_fBaseSizeX"); _fBaseSizeY = info.GetSingle("_fBaseSizeY"); _fRelCenterX = info.GetSingle("_fRelCenterX"); _fRelCenterY = info.GetSingle("_fRelCenterY"); _textureFile = info.GetString("_textureFile"); _blendMode = (TransparencyType)info.GetValue("_blendMode", typeof(TransparencyType)); _color = (Color)info.GetValue("_color", typeof(Color)); _bUseSceneBrightness = info.GetBoolean("_bUseSceneBrightness"); if (SerializationHelper.HasElement(info, "_atlasFilename")) _atlasFilename = info.GetString("_atlasFilename"); if (SerializationHelper.HasElement(info, "_fNearClip")) _fNearClip = info.GetSingle("_fNearClip"); if (SerializationHelper.HasElement(info, "_fFarClip")) _fFarClip = info.GetSingle("_fFarClip"); if (SerializationHelper.HasElement(info, "_bCastStaticShadows")) _bCastStaticShadows = info.GetBoolean("_bCastStaticShadows"); if (SerializationHelper.HasElement(info, "_objectKey")) _objectKey = info.GetString("_objectKey"); }
/// <summary> /// Called when deserializing /// </summary> /// <param name="info"></param> /// <param name="context"></param> protected ProjectorShape(SerializationInfo info, StreamingContext context) : base(info, context) { _textureFile = info.GetString("_textureFile"); _transp = (TransparencyType)info.GetValue("_transp",typeof(TransparencyType)); _fConeAngleX = info.GetSingle("_fConeAngleX"); _fConeAngleY = info.GetSingle("_fConeAngleY"); _fLength = info.GetSingle("_fLength"); _fFadeOutDist = info.GetSingle("_fFadeOutDist"); _iIntensity = info.GetByte("_iIntensity"); _color = (Color)info.GetValue("_color",typeof(Color)); if (SerializationHelper.HasElement(info,"_bLightmapped")) _bLightmapped = info.GetBoolean("_bLightmapped"); if (SerializationHelper.HasElement(info, "_geomTypeFilter")) _geomTypeFilter = (GeometryTypeMask)info.GetValue("_geomTypeFilter", typeof(GeometryTypeMask)); else _geomTypeFilter = GeometryTypeMask.All; // backwards compatibility if (SerializationHelper.HasElement(info, "_fFarClipDistance")) _fFarClipDistance = info.GetSingle("_fFarClipDistance"); // backwards compatibility if (!SerializationHelper.HasElement(info, "SupportScaling")) SetScaling_Internal(1.0f, 1.0f, 1.0f); if (SerializationHelper.HasElement(info, "_iInfluenceBitmask")) _iInfluenceBitmask = (FlagsInt32_e)info.GetValue("_iInfluenceBitmask", typeof(FlagsInt32_e)); else _iInfluenceBitmask = FlagsInt32_e.All; if (SerializationHelper.HasElement(info, "_shaderFX")) _shaderFX = (ShaderEffectConfig)info.GetValue("_shaderFX", typeof(ShaderEffectConfig)); }
/// <summary> /// Gets resulting color when blending two others. /// </summary> /// <param name="overlaying"> /// Foreground color. /// </param> /// <param name="underlaying"> /// Background color. /// </param> /// <param name="type"> /// Type of blending. /// </param> /// <returns>Blended color index.</returns> public byte GetResultingColorIndex(byte overlaying, byte underlaying, TransparencyType type) { switch(type) { case TransparencyType.None: return overlaying; case TransparencyType.Dark: return dark[underlaying*256+overlaying]; case TransparencyType.Main: return main[underlaying*256+overlaying]; case TransparencyType.Light: return light[underlaying*256+overlaying]; default: throw new ArgumentException("Unknown type.", "type"); } }
/// <summary> /// Renders all renderables in the bucket. /// </summary> public override void Render() { if (_defaultPass1RS == null) { Init(); } for (int i = 0; i < Count; i++) { IRenderable renderable = this[i]; if (renderable != null) { TransparencyType type = renderable.TransparencyType; //Account for a renderable with default type or if not a single-pass material if (type == TransparencyType.Default || renderable.Material.PassCount != 1) { type = TransparencyType.OneSided; } //If one sided, render as usual if (renderable.TransparencyType == TransparencyType.OneSided) { renderable.Render(Renderer); //Otherwise, do the two-pass render } else { //See if we have an enforced RS state already. RasterizerState oldEnRS = Renderer.EnforcedRasterizerState; //Draw normally if we have an enforced state with CullMode none or FillMode wireframe, //since these are probably meant to be enforced. if (oldEnRS != null && (oldEnRS.Cull == CullMode.None || oldEnRS.Fill == FillMode.WireFrame)) { renderable.Render(Renderer); continue; } //Grab old enforced state if it exists too, so we can put these back afterwards. DepthStencilState oldEnDSS = Renderer.EnforcedDepthStencilState; //Enforce first pass states Renderer.EnforcedDepthStencilState = _pass1DSS; Renderer.EnforcedRasterizerState = _pass1RS; //Render back faces renderable.Render(Renderer); //Enforce old DSS or clear if (oldEnDSS != null) { Renderer.EnforcedDepthStencilState = oldEnDSS; } else { Renderer.ClearEnforcedState(RenderStateType.DepthStencilState); } //Enforce second pass RS Renderer.EnforcedRasterizerState = _pass2RS; //Render front faces renderable.Render(Renderer); //Enforce old RS or clear if (oldEnRS != null) { Renderer.EnforcedRasterizerState = oldEnRS; } else { Renderer.ClearEnforcedState(RenderStateType.RasterizerState); } } } } }