public Pixel(PixelLayout layout, PixelComponentType pType, ColorRGBA color) { Layout = layout; ComponentType = pType; SetColor(color); }
protected PixelAccessor(int width, int height, PixelLayout layout, PixelComponentType pType, PixmapOrientation orientation, IntPtr pixelPointer) { PixRectInfo = new PixelRectangleInfo(width, height, layout, pType, orientation, 1); fPixelPointer = pixelPointer; }
/// <summary> /// Construct a EmptyTechnique. /// </summary> /// <param name="texture"> /// The <see cref="Texture1d"/> affected by this Technique. /// </param> /// <param name="level"> /// The specific level of the target to define. Defaults to zero. /// </param> /// <param name="pixelFormat"> /// The texture pixel format. /// </param> /// <param name="width"> /// The width of the texture. /// </param> public EmptyTechnique(Texture1d texture, uint level, PixelLayout pixelFormat, uint width) : base(texture) { _Texture1d = texture; _Level = level; _PixelFormat = pixelFormat; _Width = width; }
/// <summary> /// Construct a EmptyTechnique. /// </summary> /// <param name="target"> /// A <see cref="TextureTarget"/> that specify the texture target. /// </param> /// <param name="pixelFormat"> /// The texture pixel format. /// </param> /// <param name="width"> /// The width of the texture. /// </param> /// <param name="height"> /// The height of the texture. /// </param> /// <param name="depth"> /// The depth of the texture. /// </param> public EmptyTechnique(TextureTarget target, PixelLayout pixelFormat, uint width, uint height, uint depth) { Target = target; PixelLayout = pixelFormat; Width = width; Height = height; Depth = depth; }
/// <summary> /// Create a TextureArray2D, defining the texture size (for level 0) and the internal format. /// </summary> /// <param name="width"> /// A <see cref="UInt32"/> that specify the texture width, in pixels. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specify the texture height, in pixels. /// </param> /// <param name="layers"> /// A <see cref="UInt32"/> that specify the number of layers defining the texture array. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <param name="levels"> /// A <see cref="UInt32"/> that specifies the number of mipmap levels to define. /// </param> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> or <paramref name="levels"/> is zero. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> equals to <see cref="PixelLayout.None"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// Exception thrown if no context is current to the calling thread. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is greater than /// the maximum allowed for 2D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by current context, and <paramref name="width"/> or <paramref name="height"/> /// is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public void Create(uint width, uint height, uint layers, PixelLayout format, uint levels) { if (Immutable == false) { throw new InvalidOperationException("must be immutable"); } SetTechnique(new ImmutableEmptyTechnique(this, TextureTarget, format, width, height, layers, levels)); }
//Constructor public FormatPrefs() { unchecked { pixelLayout = (PixelLayout)0; useMipmaps = MipMapFormat.MIP_FMT_DEFAULT; alphaFormat = AlphaFormat.ALPHA_DEFAULT; } }
public void Create(PixelLayout internalFormat, uint size) { // Setup texture information mSize = size; // Setup technique for creation SetTechnique(new EmptyTechnique(internalFormat, size)); }
/// <summary> /// Create a Texture1d, defining the texture extents and the internal format. /// </summary> /// <param name="width"> /// A <see cref="UInt32"/> that specify the texture width. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> is zero. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> equals to <see cref="PixelLayout.None"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// Exception thrown if no context is current to the calling thread. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> is greater than the maximum allowed for 1D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by current context, and <paramref name="width"/> is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public void Create(uint width, PixelLayout format) { // Setup texture information PixelLayout = format; _Width = width; // Setup technique for creation SetTechnique(new EmptyTechnique(format, width)); }
public override void Edit(PixelLayout control) { using var dialog = new ReferenceDialog(PipelineController.Instance, (Value as List <string>).ToArray()); if (dialog.ShowModal(control) && _eventHandler != null) { _eventHandler(dialog.References, EventArgs.Empty); PipelineController.Instance.OnReferencesModified(); } }
/// <summary> /// Construct a ImmutableEmptyTechnique. /// </summary> /// <param name="texture"> /// The <see cref="Texture2D"/> affected by this Technique. /// </param> /// <param name="target"> /// A <see cref="TextureTarget"/> that specify the texture target. /// </param> /// <param name="pixelFormat"> /// The texture pixel format. /// </param> /// <param name="width"> /// The width of the texture. /// </param> /// <param name="height"> /// The height of the texture. /// </param> /// <param name="levels"> /// A <see cref="UInt32"/> that specify the number of levels defining the texture. /// </param> public ImmutableEmptyTechnique(Texture2D texture, TextureTarget target, PixelLayout pixelFormat, uint width, uint height, uint levels) : base(texture, target, 0, pixelFormat, width, height) { if (levels == 0) { throw new ArgumentException("invalid value", "levels"); } _MipmapLevels = levels; }
/// <summary> /// Create Texture2d data, defining only the extents and the internal format. /// </summary> /// <param name="ctx"> /// A <see cref="GraphicsContext"/> used for creating this Texture. /// </param> /// <param name="width"> /// A <see cref="UInt32"/> that specify the texture width. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specify the texture height. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is zero. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> equals to <see cref="PixelLayout.None"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// Exception thrown if <paramref name="ctx"/> is null and no context is current to the calling thread. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is greater than /// the maximum allowed for 2D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by <paramref name="ctx"/>, and <paramref name="width"/> or <paramref name="height"/> /// is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public void Create(GraphicsContext ctx, uint width, uint height, PixelLayout format, uint levels) { CheckCurrentContext(ctx); // Define technique Create(width, height, format, levels); // Actually create texture Create(ctx); }
/// <summary> /// Create a Texture2D, defining the texture extents and the internal format. /// </summary> /// <param name="width"> /// A <see cref="UInt32"/> that specify the texture width. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specify the texture height. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <param name="level"> /// A <see cref="UInt32"/> that specify the texture level to create/update. /// </param> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is zero. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> equals to <see cref="PixelLayout.None"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// Exception thrown if no context is current to the calling thread. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is greater than /// the maximum allowed for 2D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by current context, and <paramref name="width"/> or <paramref name="height"/> /// is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public void Create(uint width, uint height, uint level, PixelLayout format) { if (ImmutableFix) { throw new InvalidOperationException("immutable storage (see GL_ARB_texture_storage)"); } SetTechnique(new EmptyTechnique(this, TextureTarget, level, format, width, height)); }
public override void Edit(PixelLayout control) { var dialog = new PathDialog(PipelineController.Instance, Value.ToString()); if (dialog.Show(control) && _eventHandler != null) { _eventHandler(dialog.Path, EventArgs.Empty); } }
public override void Edit(PixelLayout control) { var dialog = new ReferenceDialog(PipelineController.Instance, (Value as List <string>).ToArray()); if (dialog.Run(control) == DialogResult.Ok && _eventHandler != null) { _eventHandler(dialog.References, EventArgs.Empty); } }
/// <summary> /// Construct a PixelLayoutInfo for a pixel format. /// </summary> /// <param name="pType"> /// A <see cref="PixelLayout"/> that specify the pixel type (unique characteristic). All required information /// is retrieved using attributes of the enumeration field. /// </param> public PixelLayoutInfo(PixelLayout pType) { if (pType == PixelLayout.None) { throw new ArgumentException("invalid pixel type " + pType, "pType"); } Type pixelType = typeof(PixelLayout); PixelColorspaceAttribute colorSpaceAttribute = (PixelColorspaceAttribute)Attribute.GetCustomAttribute(pixelType.GetField(Enum.GetName(pixelType, pType)), typeof(PixelColorspaceAttribute)); PixelComponentsAttribute colorComponentsAttribute = (PixelComponentsAttribute)Attribute.GetCustomAttribute(pixelType.GetField(Enum.GetName(pixelType, pType)), typeof(PixelComponentsAttribute)); PixelPlanesAttribute colorPlanesAttribute = (PixelPlanesAttribute)Attribute.GetCustomAttribute(pixelType.GetField(Enum.GetName(pixelType, pType)), typeof(PixelPlanesAttribute)); PixelPrecisionAttribute colorPrecisionAttribute = (PixelPrecisionAttribute)Attribute.GetCustomAttribute(pixelType.GetField(Enum.GetName(pixelType, pType)), typeof(PixelPrecisionAttribute)); PixelNonLinearAttribute colorNonLinearAttribute = (PixelNonLinearAttribute)Attribute.GetCustomAttribute(pixelType.GetField(Enum.GetName(pixelType, pType)), typeof(PixelNonLinearAttribute)); PixelStructureAttribute structAttribute = (PixelStructureAttribute)Attribute.GetCustomAttribute(pixelType.GetField(Enum.GetName(pixelType, pType)), typeof(PixelStructureAttribute)); if (colorSpaceAttribute == null) { throw new InvalidOperationException(String.Format("pixel format {0} does not declare PixelColorspaceAttribute")); } if ((colorComponentsAttribute == null) && (colorPlanesAttribute == null)) { throw new InvalidOperationException(String.Format("pixel format {0} does not declare PixelComponentsAttribute or PixelPlanesAttribute")); } if (colorPrecisionAttribute == null) { throw new InvalidOperationException(String.Format("pixel format {0} does not declare PixelPrecisionAttribute")); } // Store type DataFormat = pType; // Store color space ColorSpace = colorSpaceAttribute.PixelSpace; // Store components bits ComponentsCount = 0; ChromaXRatio = ChromaYRatio = 0; if (colorComponentsAttribute != null) { ComponentsCount = colorComponentsAttribute.PixelComponents; ChromaXRatio = ChromaYRatio = 1; } if (colorPlanesAttribute != null) { ComponentsCount = colorPlanesAttribute.PixelPlanes; ChromaXRatio = colorPlanesAttribute.XRatio; ChromaYRatio = colorPlanesAttribute.YRatio; } PixelBits = colorPrecisionAttribute.PixelBits; PixelBytes = (byte)(((PixelBits + 7) / 8) & 0xFF); Linear = colorNonLinearAttribute == null; _PixelStructType = (structAttribute != null) ? structAttribute.PixelStructureType : null; }
Control PixelLayout() { var control = new PixelLayout(); control.Add(new TextArea { Text = "Some text that is contained in a pixel layout." }, Point.Empty); return(control); }
/// <summary> /// Create a Texture2d, defining the texture extents and the internal format. /// </summary> /// <param name="width"> /// A <see cref="UInt32"/> that specify the texture width. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specify the texture height. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is zero. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> equals to <see cref="PixelLayout.None"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// Exception thrown if no context is current to the calling thread. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is greater than /// the maximum allowed for 2D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by current context, and <paramref name="width"/> or <paramref name="height"/> /// is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public void Create(uint width, uint height, PixelLayout format) { // Setup texture information PixelLayout = format; _Width = width; _Height = height; // Setup technique for creation SetTechnique(new EmptyTechnique(TextureTarget, format, width, height)); }
public PixelRectangleInfo(int width, int height, PixelLayout layout, PixelComponentType compType, PixmapOrientation orient, int alignment) { Width = width; Height = height; Layout = layout; ComponentType = compType; Orientation = orient; Alignment = alignment; BytesPerRow = GetBytesPerRow(); }
public void Create(GraphicsContext ctx, PixelLayout internalFormat, uint size) { // Setup texture information mSize = size; // Setup technique for creation SetTechnique(new EmptyTechnique(internalFormat, size)); // Actually create texture Create(ctx); }
public NiSourceTexture(NiFile niFile) : base(niFile) { useExternal = niFile.Reader.ReadByte(); FileName = niFile.Reader.ReadLengthPrefixedString(); pixelLayout = (PixelLayout)niFile.Reader.ReadInt32(); useMipMaps = (MipMapFormat)niFile.Reader.ReadInt32(); alphaFormat = (AlphaFormat)niFile.Reader.ReadInt32(); isStatic = niFile.Reader.ReadByte(); }
/// <summary> /// Construct a EmptyTechnique. /// </summary> /// <param name="texture"> /// The <see cref="TextureArray2d"/> affected by this Technique. /// </param> /// <param name="target"> /// A <see cref="TextureTarget"/> that specify the texture target. /// </param> /// <param name="pixelFormat"> /// The texture pixel format. /// </param> /// <param name="width"> /// The width of the texture. /// </param> /// <param name="height"> /// The height of the texture. /// </param> /// <param name="layers"> /// A <see cref="UInt32"/> that specify the number of layers defining the texture array. /// </param> public EmptyTechnique(TextureArray2d texture, TextureTarget target, PixelLayout pixelFormat, uint width, uint height, uint layers) : base(texture) { _TextureArray2d = texture; _Target = target; _PixelFormat = pixelFormat; _Width = width; _Height = height; _Layers = layers; }
/// <summary> /// Construct a EmptyTechnique. /// </summary> /// <param name="texture"> /// The <see cref="Texture2d"/> affected by this Technique. /// </param> /// <param name="target"> /// A <see cref="TextureTarget"/> that specify the texture target. /// </param> /// <param name="level"> /// The specific level of the target to be defined. /// </param> /// <param name="pixelFormat"> /// The texture pixel format. /// </param> /// <param name="width"> /// The width of the texture. /// </param> /// <param name="height"> /// The height of the texture. /// </param> public EmptyTechnique(Texture2d texture, TextureTarget target, uint level, PixelLayout pixelFormat, uint width, uint height) : base(texture) { _Texture2d = texture; _Target = target; _Level = level; _PixelFormat = pixelFormat; _Width = width; _Height = height; }
/// <summary> /// Create Texture2d from a Image instance. /// </summary> /// <param name="ctx"> /// A <see cref="GraphicsContext"/> used for creating this Texture. If it null, the current context /// will be used. /// </param> /// <param name="image"> /// An <see cref="Image"/> holding the texture data. /// </param> /// <exception cref="ArgumentNullException"> /// Exception throw if <paramref name="image"/> is null. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="image"/> pixel data is not allocated (i.e. image not defined). /// </exception> /// <exception cref="InvalidOperationException"> /// Exception thrown if <paramref name="ctx"/> is null and no context is current to the calling thread. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="image"/> width or height are greater than the maximum allowed for 2D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by <paramref name="ctx"/> (or the current context if <paramref name="ctx"/> is /// null), and <paramref name="image"/> width or height are not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="image"/> format (<see cref="Image.PixelFormat"/> is not a supported internal format. /// </exception> public void Create(GraphicsContext ctx, PixelLayout internalFormat, Image image, uint layer) { CheckCurrentContext(ctx); if (layer >= Depth) { throw new ArgumentOutOfRangeException("layer", "exceeding upper boundary"); } SetTechnique(new ImageTechnique(this, TextureTarget, internalFormat, image, layer)); Create(ctx); }
Control ExpandedHeight() { var layout = new PixelLayout(); layout.Add(new Label { BackgroundColor = Colors.Red, Text = "Expanded Height" }, 50, 50); return(new Scrollable { ExpandContentWidth = false, Content = layout }); }
Control Default() { var layout = new PixelLayout(); layout.Add(new Label { BackgroundColor = Colors.Red, Text = "Expanded Width/Height (default)" }, 50, 50); defaultScrollable.Content = layout; return(defaultScrollable); }
public StatusPanel(Main parent, int width, int height) { main = parent; Size = new Size(width, height); eotWhite = true; // Main panel mainPanel = new Drawable() { Size = new Size(width, height) }; mainPanel.Paint += MainPanel_Paint; MainPanelLayout = new PixelLayout() { Size = new Size(mainPanel.Width, mainPanel.Height) }; // Stats panel statsPanel = new Drawable() { Size = new Size(240, 60) }; statsPanel.Paint += StatsPanel_Paint; statsPanel.MouseUp += Panel_Click; MainPanelLayout.Add(statsPanel, 11, 38); // Unit panel unitPanel = new Drawable() { Size = new Size(240, this.Height - 117) }; unitPanel.Paint += UnitPanel_Paint; unitPanel.MouseUp += Panel_Click; MainPanelLayout.Add(unitPanel, 11, 106); mainPanel.Content = MainPanelLayout; Content = mainPanel; Game.OnMapEvent += MapEventHappened; //Main.OnMapEvent += MapEventHappened; //Game.OnWaitAtTurnEnd += InitiateWaitAtTurnEnd; Game.OnPlayerEvent += PlayerEventHappened; Game.OnUnitEvent += UnitEventHappened; // Timer for "end of turn" message timer = new UITimer() { Interval = 0.5 }; timer.Elapsed += (sender, e) => unitPanel.Invalidate(); SizeChanged += OnSizeChanged; }
public ColourPad(CharacterHandler handler) { this.Handler = handler; this.Handler.ColourStart = start; this.Handler.DrawAttributeChanged += new EventHandler <EventArgs> (HandleColourChanged).MakeWeak((e) => this.Handler.DrawAttributeChanged -= e); this.Handler.CurrentPage.PaletteChanged += new EventHandler <EventArgs> (delegate { SetColours(); UpdateButtons(); Invalidate(); }).MakeWeak((e) => this.Handler.CurrentPage.PaletteChanged -= e); var boxSize = new Size(30, 30); int boxOffset = 10; int boxesPadding = 10; int boxesOffset = boxSize.Width + boxOffset + boxesPadding; max = 8; //Math.Min (16, Palette.Count / 2); Size = new Size(40, boxesOffset + (max * 18) + 16 + 17); foreground = new FBColourBox { Size = boxSize, Pad = this }; background = new FBColourBox { Size = boxSize, Pad = this }; SetColours(); var layout = new PixelLayout(); layout.Add(background, boxOffset, boxOffset); layout.Add(foreground, 0, 0); colours = new SelectColourBox[max * 2]; for (int i = 0; i < max; i++) { CreateButton(layout, i, 2, boxesOffset + i * 18); CreateButton(layout, i + max, 22, boxesOffset + i * 18); } layout.Add(SelectButton(), 10, this.Size.Height - 16); layout.Add(UpButton(), 2, this.Size.Height - 16 - 15); layout.Add(DownButton(), 22, this.Size.Height - 16 - 15); Content = layout; UpdateButtons(); }
Control ColourButtons() { var layout = new PixelLayout { Size = new Size(17, 17 * 2 + 4) }; layout.Add(AddButton(), 0, 0); layout.Add(RemoveButton(), 0, 17 + 4); return(layout); }
void InitializeComponent() { Title = "HVH.Client"; BackgroundColor = Colors.White; Icon = new Icon(Directory.GetCurrentDirectory() + "/assets/helmholtz_owl.ico"); ClientSize = new Size(280, 430); Resizable = false; Minimizable = false; Maximizable = false; controls["logo"] = new ImageView { Image = Utility.LoadBitmap("assets/helmholtz_owl.png"), Size = new Size(200, -1) }; controls["roomControl"] = new Button { Text = "Room Control", Size = new Size(240, 30), Enabled = Client.Instance?.Status.Type != UserType.Normal }; controls["issueReport"] = new Button { Text = "Issue Reporting", Size = new Size(240, 30), Enabled = Client.Instance?.Status.Type != UserType.Normal }; controls["adminPanel"] = new Button { Text = "Admin Panel", Size = new Size(240, 30), Enabled = Client.Instance?.Status.Type == UserType.Admin }; controls["seperator"] = new ProgressBar { BackgroundColor = Colors.Black, Indeterminate = false, Value = 0, Size = new Size(240, 1) }; controls["logout"] = new Button { Text = "Logout", Size = new Size(240, 30) }; // Events (controls["logout"] as Button).Click += delegate { Client.Instance.SendLogout(); }; (controls["roomControl"] as Button).Click += delegate { Application.Instance.MainForm = new RoomControlForm(); Application.Instance.MainForm.Show(); Visible = false; }; PixelLayout layout = new PixelLayout(); layout.Add(controls["logo"], 40, 10); layout.Add(controls["roomControl"], 20, 250); layout.Add(controls["issueReport"], 20, 290); layout.Add(controls["adminPanel"], 20, 330); layout.Add(controls["seperator"], 20, 370); layout.Add(controls["logout"], 20, 380); Content = layout; }
/// <summary> /// Create a Texture3d, defining the texture extents and the internal format. /// </summary> /// <param name="ctx"> /// A <see cref="GraphicsContext"/> used for creating this Texture. /// </param> /// <param name="width"> /// A <see cref="UInt32"/> that specify the texture width. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specify the texture height. /// </param> /// <param name="depth"> /// A <see cref="UInt32"/> that specify the texture depth. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is zero. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> equals to <see cref="PixelFormat.None"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// Exception thrown if no context is current to the calling thread. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is greater than /// the maximum allowed for 2D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by current context, and <paramref name="width"/> or <paramref name="height"/> /// is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public void Create(GraphicsContext ctx, uint width, uint height, uint depth, PixelLayout format) { if (ctx == null) { throw new ArgumentNullException("ctx"); } // Define technique Create(width, height, depth, format); // Actually create texture Create(ctx); }
/// <summary> /// Create a Texture3d, defining the texture extents and the internal format. /// </summary> /// <param name="ctx"> /// A <see cref="GraphicsContext"/> used for creating this Texture. /// </param> /// <param name="images"> /// An array of <see cref="Image"/> that specify the texture data. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="images"/> is null. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="images"/> has no items, or every item hasn't the same width and height. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if width, height or depth is greater than the maximum allowed for 3D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by current context, and width, height or depth /// is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public void Create(GraphicsContext ctx, Image[] images, PixelLayout format) { if (ctx == null) { throw new ArgumentNullException("ctx"); } // Define technique Create(images, format); // Actually create texture Create(ctx); }
public override void Edit(PixelLayout control) { var dialog = new ColorDialog(); dialog.Color = color; if (dialog.ShowDialog(control) == DialogResult.Ok && _eventHandler != null && dialog.Color != color) { var col = new Microsoft.Xna.Framework.Color(dialog.Color.Rb, dialog.Color.Gb, dialog.Color.Bb, dialog.Color.Ab); _eventHandler(col, EventArgs.Empty); } }
void CreateButton(PixelLayout layout, int index, int x, int y) { var b = new SelectColourBox { Pad = this, Size = new Size(16, 16), Index = index, Enabled = index < Palette.Count }; colours[index] = b; layout.Add(b, x, y); }
public Pixel(PixelLayout layout, PixelComponentType pType, byte[] data, int startIndex) { Layout = layout; ComponentType = pType; int pixelLength = PixelInformation.GetBytesPerPixel(layout, pType); // Allocate some space to hold the pixel data Data = new byte[pixelLength]; // Copy the pixel data into the new space Array.Copy(data, startIndex, Data, 0, pixelLength); }
/// <summary> /// Construct a render buffer. /// </summary> /// <param name="type"> /// A <see cref="Type"/> that specify the type of the buffer. This parameter /// influence the framebuffer attachment, and the possible formats. /// </param> /// <param name="internalFormat"> /// A <see cref="PixelLayout"/> that specify the internal OpenGL format for this /// RenderBuffer. From OpenGL 3.2 specification: /// @verbatim /// Implementations are required to support the same internal formats for renderbuffers /// as the required formats for textures enumerated in section 3.8.1, with the exception /// of the color formats labelled “texture-only”. Requesting one of these internal /// formats for a renderbuffer will allocate at least the internal component sizes and /// exactly the component types shown for that format in tables 3.12- 3.13. /// @endverbatim /// </param> public RenderBuffer(Type type, PixelLayout internalFormat, uint w, uint h) { if (w >= GraphicsContext.CurrentCaps.Limits.MaxRenderBufferSize) throw new ArgumentException("exceed maximum size", "w"); if (h >= GraphicsContext.CurrentCaps.Limits.MaxRenderBufferSize) throw new ArgumentException("exceed maximum size", "w"); // Set buffer type _Type = type; // Store internal format _InternalFormat = internalFormat; _Width = w; _Height = h; }
/// <summary> /// Construct a PixelLayoutInfo for a pixel format. /// </summary> /// <param name="pType"> /// A <see cref="PixelLayout"/> that specifies the pixel type (unique characteristic). All required information /// is retrieved using attributes of the enumeration field. /// </param> public PixelLayoutInfo(PixelLayout pType) { if (pType == PixelLayout.None) throw new ArgumentException("invalid pixel type " + pType, "pType"); Type pixelType = typeof(PixelLayout); PixelColorspaceAttribute colorSpaceAttribute = (PixelColorspaceAttribute)Attribute.GetCustomAttribute(pixelType.GetField(Enum.GetName(pixelType, pType)), typeof(PixelColorspaceAttribute)); PixelComponentsAttribute colorComponentsAttribute = (PixelComponentsAttribute)Attribute.GetCustomAttribute(pixelType.GetField(Enum.GetName(pixelType, pType)), typeof(PixelComponentsAttribute)); PixelPlanesAttribute colorPlanesAttribute = (PixelPlanesAttribute)Attribute.GetCustomAttribute(pixelType.GetField(Enum.GetName(pixelType, pType)), typeof(PixelPlanesAttribute)); PixelPrecisionAttribute colorPrecisionAttribute = (PixelPrecisionAttribute)Attribute.GetCustomAttribute(pixelType.GetField(Enum.GetName(pixelType, pType)), typeof(PixelPrecisionAttribute)); PixelNonLinearAttribute colorNonLinearAttribute = (PixelNonLinearAttribute)Attribute.GetCustomAttribute(pixelType.GetField(Enum.GetName(pixelType, pType)), typeof(PixelNonLinearAttribute)); PixelStructureAttribute structAttribute = (PixelStructureAttribute)Attribute.GetCustomAttribute(pixelType.GetField(Enum.GetName(pixelType, pType)), typeof(PixelStructureAttribute)); if (colorSpaceAttribute == null) throw new InvalidOperationException(String.Format("pixel format {0} does not declare PixelColorspaceAttribute")); if ((colorComponentsAttribute == null) && (colorPlanesAttribute == null)) throw new InvalidOperationException(String.Format("pixel format {0} does not declare PixelComponentsAttribute or PixelPlanesAttribute")); if (colorPrecisionAttribute == null) throw new InvalidOperationException(String.Format("pixel format {0} does not declare PixelPrecisionAttribute")); // Store type DataFormat = pType; // Store color space ColorSpace = colorSpaceAttribute.PixelSpace; // Store components bits ComponentsCount = 0; ChromaXRatio = ChromaYRatio = 0; if (colorComponentsAttribute != null) { ComponentsCount = colorComponentsAttribute.PixelComponents; ChromaXRatio = ChromaYRatio = 1; } if (colorPlanesAttribute != null) { ComponentsCount = colorPlanesAttribute.PixelPlanes; ChromaXRatio = colorPlanesAttribute.XRatio; ChromaYRatio = colorPlanesAttribute.YRatio; } PixelBits = colorPrecisionAttribute.PixelBits; PixelBytes = (byte)(((PixelBits + 7) / 8) & 0xFF); Linear = colorNonLinearAttribute == null; mPixelStructType = (structAttribute != null) ? structAttribute.PixelStructureType : null; }
/// <summary> /// Surface format with specified color and depth (no stencil, no multisample, no double/stereo buffering). /// </summary> /// <param name="color"> /// A <see cref="PixelLayout"/> that specify the format of the color buffer. /// </param> /// <param name="depth"> /// A <see cref="UInt32"/> that specify the bit count of the depth buffer fragment. /// </param> /// <remarks> /// <para> /// The buffer configurations are considered required but degradable. If it necessary a specific resolution, /// define those configurations using the related <i>Define*</i> routine. /// </para> /// </remarks> public GraphicsBuffersFormat(PixelLayout color, uint depth) { DefineColorBuffer(color); DefineDepthBuffer(depth); }
public static void DrawPixels(int width, int height, PixelLayout format, PixelComponentType type, float[] pixels) { gl.glDrawPixels(width, height, (int)format, (int)type, pixels); }
public static void glReadPixels(int x, int y, int width, int height, PixelLayout format, PixelComponentType type, float[] pixels) { gl.glReadPixels(x, y, width, height, (int)format, (int)type, pixels); }
/// <summary> /// Define RenderSurface color buffer. /// </summary> /// <param name="pType"> /// A <see cref="PixelLayout"/> /// </param> /// <param name="policy"> /// A <see cref="BufferPolicy"/> /// </param> public void DefineColorSRGBBuffer(PixelLayout pType, BufferPolicy policy) { if (pType == PixelLayout.None) throw new ArgumentException("invalid pixel type", "pType"); // Define buffer DefineBuffer(BufferType.ColorSRGB, policy); // Set color buffer bits. mColorType = pType; }
static void ConvertPixelFormat(System.Drawing.Bitmap bitmap, out PixelLayout to) { System.Drawing.Imaging.PixelFormat from = bitmap.PixelFormat; int flags = bitmap.Flags; bool sRGB = false; #if false foreach (System.Drawing.Imaging.PropertyItem exifProperty in bitmap.PropertyItems) { switch (exifProperty.Id) { case ImageCodecPlugin.ExifTagColorSpace: ImageCodecPlugin.ExifColorSpace value = (ImageCodecPlugin.ExifColorSpace)BitConverter.ToUInt16(exifProperty.Value, 0); switch (value) { case ImageCodecPlugin.ExifColorSpace.sRGB: sRGB = true; break; default: break; } break; case ImageCodecPlugin.ExifTagGamma: UInt32 a1 = BitConverter.ToUInt32(exifProperty.Value, 0); UInt32 a2 = BitConverter.ToUInt32(exifProperty.Value, 4); Double gamma = (Double)a1 / (Double)a2; break; } } #endif if ((flags & (int)System.Drawing.Imaging.ImageFlags.ColorSpaceRgb) != 0) { ConvertPixelFormatRgb(from, out to, sRGB); } else if ((flags & (int)System.Drawing.Imaging.ImageFlags.ColorSpaceGray) != 0) { switch (from) { case System.Drawing.Imaging.PixelFormat.Format1bppIndexed: case System.Drawing.Imaging.PixelFormat.Format4bppIndexed: case System.Drawing.Imaging.PixelFormat.Format8bppIndexed: to = PixelLayout.GRAY8; break; case System.Drawing.Imaging.PixelFormat.Format16bppGrayScale: to = PixelLayout.GRAY16; break; case System.Drawing.Imaging.PixelFormat.Format32bppArgb: to = PixelLayout.BGRA32; break; default: throw new ArgumentException(String.Format("GRAY pixel format {0} not supported", from)); } } else if ((flags & (int)System.Drawing.Imaging.ImageFlags.ColorSpaceYcck) != 0) { throw new ArgumentException(String.Format("YCCK pixel format {0} not supported", from)); } else if ((flags & (int)System.Drawing.Imaging.ImageFlags.ColorSpaceYcbcr) != 0) { ConvertPixelFormatRgb(from, out to, sRGB); } else if ((flags & (int)System.Drawing.Imaging.ImageFlags.ColorSpaceCmyk) != 0) { throw new ArgumentException(String.Format("CMYK pixel format {0} not supported", from)); } else { throw new ArgumentException(String.Format("not RGB/GRAY pixel format {0} not supported", from)); } }
/// <summary> /// Create TextureRectangle data, defining only the extents and the internal format. /// </summary> /// <param name="width"> /// A <see cref="UInt32"/> that specify the texture width. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specify the texture height. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is zero. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> equals to <see cref="PixelFormat.None"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// Exception thrown if <paramref name="ctx"/> is null and no context is current to the calling thread. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is greater than /// the maximum allowed for 2D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by the current context and <paramref name="width"/> /// or <paramref name="height"/> is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public TextureRectangle(uint width, uint height, PixelLayout format) : base(width, height, format) { }
/// <summary> /// Create a Texture3d, defining the texture extents and the internal format. /// </summary> /// <param name="images"> /// An array of <see cref="Image"/> that specify the texture data. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="images"/> is null. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="images"/> has no items, or every item hasn't the same width and height. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if width, height or depth is greater than the maximum allowed for 3D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by current context, and width, height or depth /// is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public void Create(Image[] images, PixelLayout format) { if (images == null) throw new ArgumentNullException("images"); if (images.Length == 0) throw new ArgumentException("no images", "images"); if (!Array.TrueForAll(images, delegate(Image item) { return (item != null); })) throw new ArgumentException("null item in image set", "images"); if (!Array.TrueForAll(images, delegate(Image item) { return (item.Width == images[0].Width && item.Height == images[0].Height); })) throw new ArgumentException("eterogeneous size in image set", "images"); uint width = images[0].Width, height = images[0].Height; // Setup texture information PixelLayout = format; _Width = width; _Height = height; _Depth = (uint)images.Length; // Setup technique for creation SetTechnique(new ImageTechnique(TextureTarget, format, images)); }
private static void ConvertPixelFormatRgb(System.Drawing.Imaging.PixelFormat from, out PixelLayout to, bool sRGB) { switch (from) { case System.Drawing.Imaging.PixelFormat.Format1bppIndexed: case System.Drawing.Imaging.PixelFormat.Format4bppIndexed: case System.Drawing.Imaging.PixelFormat.Format8bppIndexed: to = PixelLayout.BGR24; break; case System.Drawing.Imaging.PixelFormat.Format16bppRgb555: to = PixelLayout.BGR15; break; case System.Drawing.Imaging.PixelFormat.Format16bppRgb565: to = PixelLayout.BGR16; break; case System.Drawing.Imaging.PixelFormat.Format24bppRgb: to = sRGB ? PixelLayout.SBGR24 : PixelLayout.BGR24; break; case System.Drawing.Imaging.PixelFormat.Format32bppRgb: to = PixelLayout.BGRA32; break; case System.Drawing.Imaging.PixelFormat.Format16bppArgb1555: to = PixelLayout.BGR15; break; case System.Drawing.Imaging.PixelFormat.Format16bppGrayScale: to = PixelLayout.GRAY16; break; case System.Drawing.Imaging.PixelFormat.Format48bppRgb: to = PixelLayout.BGR48; break; case System.Drawing.Imaging.PixelFormat.Format64bppPArgb: throw new ArgumentException(String.Format("RGB pixel format {0} not supported", from)); case System.Drawing.Imaging.PixelFormat.Canonical: to = (sRGB) ? PixelLayout.SBGR24 : PixelLayout.BGR24; break; case System.Drawing.Imaging.PixelFormat.Format32bppArgb: to = PixelLayout.BGRA32; break; case System.Drawing.Imaging.PixelFormat.Format64bppArgb: throw new ArgumentException(String.Format("RGB pixel format {0} not supported", from)); default: throw new ArgumentException(String.Format("RGB pixel format {0} not supported", from)); } }
/// <summary> /// Create a Texture3d, defining the texture extents and the internal format. /// </summary> /// <param name="ctx"> /// A <see cref="GraphicsContext"/> used for creating this Texture. /// </param> /// <param name="width"> /// A <see cref="UInt32"/> that specify the texture width. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specify the texture height. /// </param> /// <param name="depth"> /// A <see cref="UInt32"/> that specify the texture depth. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is zero. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> equals to <see cref="PixelFormat.None"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// Exception thrown if no context is current to the calling thread. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is greater than /// the maximum allowed for 2D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by current context, and <paramref name="width"/> or <paramref name="height"/> /// is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public void Create(GraphicsContext ctx, uint width, uint height, uint depth, PixelLayout format) { if (ctx == null) throw new ArgumentNullException("ctx"); // Define technique Create(width, height, depth, format); // Actually create texture Create(ctx); }
/// <summary> /// Create a Texture3d, defining the texture extents and the internal format. /// </summary> /// <param name="width"> /// A <see cref="UInt32"/> that specify the texture width. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specify the texture height. /// </param> /// <param name="depth"> /// A <see cref="UInt32"/> that specify the texture depth. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is zero. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> equals to <see cref="PixelFormat.None"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// Exception thrown if no context is current to the calling thread. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is greater than /// the maximum allowed for 2D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by current context, and <paramref name="width"/> or <paramref name="height"/> /// is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public void Create(uint width, uint height, uint depth, PixelLayout format) { // Setup texture information PixelLayout = format; _Width = width; _Height = height; _Depth = depth; // Setup technique for creation SetTechnique(new EmptyTechnique(TextureTarget, format, width, height, depth)); }
/// <summary> /// Construct a EmptyTechnique. /// </summary> /// <param name="target"> /// A <see cref="TextureTarget"/> that specify the texture target. /// </param> /// <param name="pixelFormat"> /// The texture pixel format. /// </param> /// <param name="images"> /// The image set of the texture. /// </param> public ImageTechnique(TextureTarget target, PixelLayout pixelFormat, Image[] images) { if (images == null) throw new ArgumentNullException("images"); if (images.Length == 0) throw new ArgumentException("no images", "images"); if (!Array.TrueForAll(images, delegate(Image item) { return (item != null); })) throw new ArgumentException("null item in image set", "images"); if (!Array.TrueForAll(images, delegate(Image item) { return (item.Width == images[0].Width && item.Height == images[0].Height); })) throw new ArgumentException("eterogeneous size in image set", "images"); Target = target; PixelLayout = pixelFormat; Images = images; Array.ForEach(Images, delegate(Image image) { image.IncRef(); }); // Referenced }
internal void DrawPixels(int width, int height, PixelLayout format, PixelComponentType type, float[] pixels) { gl.glDrawPixels(width, height, (int)format, (int)type, pixels); CheckException(); }
/// <summary> /// Create TextureRectangle data, defining only the extents and the internal format. /// </summary> /// <param name="ctx"> /// A <see cref="GraphicsContext"/> used for creating this Texture. If it null, the current context /// will be used. /// </param> /// <param name="width"> /// A <see cref="UInt32"/> that specify the texture width. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specify the texture height. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is zero. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> equals to <see cref="PixelFormat.None"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// Exception thrown if <paramref name="ctx"/> is null and no context is current to the calling thread. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is greater than /// the maximum allowed for 2D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by <paramref name="ctx"/> (or by the current context is <paramref name="ctx"/> is /// null), and <paramref name="width"/> or <paramref name="height"/> is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public TextureRectangle(GraphicsContext ctx, uint width, uint height, PixelLayout format) : base(ctx, width, height, format) { }
internal void ReadPixels(int x, int y, int width, int height, PixelLayout format, PixelComponentType type, byte[] pixels) { gl.glReadPixels(x, y, width, height, (int)format, (int)type, pixels); CheckException(); }
/// <summary> /// Download Texture data to an Image instance. /// </summary> /// <param name="ctx"> /// A <see cref="GraphicsContext"/> used for downloading texture data. /// </param> /// <param name="pType"> /// A <see cref="OpenGL.PixelLayout"/> determining the pixel format of the downloaded data. /// </param> /// <param name="target"> /// A <see cref="TextureTarget"/> that specify the texture target. /// </param> /// <returns> /// /// </returns> protected Image[] Get(GraphicsContext ctx, PixelLayout pType, TextureTarget target) { // Bind this Texture Bind(ctx); // Get texture extents int width, height; Gl.GetTexLevelParameter(TextureTarget, 0, GetTextureParameter.TextureWidth, out width); Gl.GetTexLevelParameter(TextureTarget, 0, GetTextureParameter.TextureHeight, out height); if ((width <= 0) || (height <= 0)) throw new InvalidOperationException(String.Format("invalid texture extents {0}x{1}", width, height)); // Create image Image image = new Image(pType, (uint)width, (uint)height); // Set pixel transfer foreach (int alignment in new int[] { 8, 4, 2, 1 }) { if (image.Stride % alignment == 0) { Gl.PixelStore(PixelStoreParameter.PackAlignment, alignment); break; } } // Download texture contents Gl.GetTexImage(target, 0, Pixel.GetGlFormat(pType), Pixel.GetPixelType(pType), image.ImageBuffer); // Unbind this texture Unbind(ctx); return (new Image[] { image }); }
/// <summary> /// Surface format with specified color (no depth, no stencil, no multisample, no double/stereo buffering). /// </summary> /// <param name="color"> /// A <see cref="PixelLayout"/> that specify the format of the color buffer. /// </param> /// <remarks> /// <para> /// The buffer configurations are considered required but degradable. If it necessary a specific resolution, /// define those configurations using the related <i>Define*</i> routine. /// </para> /// </remarks> public GraphicsBuffersFormat(PixelLayout color) { DefineColorBuffer(color); }
//internal void DrawPixels(GLPixelRectangleInfo pixelRect) //{ // if (pixelRect.BufferObject == null) // return ; // IntPtr mappedPtr = pixelRect.BufferObject.MapBuffer(BufferAccess.ReadOnly); // if (mappedPtr == null) // return ; // DrawPixels(pixelRect.Width, pixelRect.Height, pixelRect.PixelFormat, pixelRect.PixelType, mappedPtr); // pixelRect.BufferObject.UnmapBuffer(); //} //public void DrawPixels(int x, int y, GLPixelRectangleInfo pixelRect) //{ // RasterPos2i(x, y); // DrawPixels(pixelRect); //} public void DrawPixels(int width, int height, PixelLayout format, PixelComponentType type, IntPtr pixels) { gl.glDrawPixels(width, height, (int)format, (int)type, pixels); CheckException(); }
/// <summary> /// Create a Texture3d, defining the texture extents and the internal format. /// </summary> /// <param name="ctx"> /// A <see cref="GraphicsContext"/> used for creating this Texture. /// </param> /// <param name="images"> /// An array of <see cref="Image"/> that specify the texture data. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="images"/> is null. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="images"/> has no items, or every item hasn't the same width and height. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if width, height or depth is greater than the maximum allowed for 3D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by current context, and width, height or depth /// is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public void Create(GraphicsContext ctx, Image[] images, PixelLayout format) { if (ctx == null) throw new ArgumentNullException("ctx"); // Define technique Create(images, format); // Actually create texture Create(ctx); }
/// <summary> /// Construct a Texture3d, defining the texture extents and the internal format. /// </summary> /// <param name="width"> /// A <see cref="UInt32"/> that specify the texture width. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specify the texture height. /// </param> /// <param name="depth"> /// A <see cref="UInt32"/> that specify the texture depth. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is zero. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> equals to <see cref="PixelFormat.None"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// Exception thrown if no context is current to the calling thread. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is greater than /// the maximum allowed for 2D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by current context, and <paramref name="width"/> or <paramref name="height"/> /// is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public Texture3d(GraphicsContext ctx, uint width, uint height, uint depth, PixelLayout format) { Create(ctx, width, height, depth, format); }
static void ConvertPixelFormat(PixelLayout from, out System.Drawing.Imaging.PixelFormat to, out int flags) { switch (from) { case PixelLayout.GRAY8: to = System.Drawing.Imaging.PixelFormat.Format8bppIndexed; flags = (int)ImageFlags.ColorSpaceGray; break; case PixelLayout.GRAY16: to = System.Drawing.Imaging.PixelFormat.Format16bppGrayScale; flags = (int)ImageFlags.ColorSpaceGray; break; case PixelLayout.BGR15: to = System.Drawing.Imaging.PixelFormat.Format16bppRgb555; flags = (int)ImageFlags.ColorSpaceRgb; break; case PixelLayout.BGR16: to = System.Drawing.Imaging.PixelFormat.Format16bppRgb565; flags = (int)ImageFlags.ColorSpaceRgb; break; case PixelLayout.BGR24: to = System.Drawing.Imaging.PixelFormat.Format24bppRgb; flags = (int)ImageFlags.ColorSpaceRgb; break; case PixelLayout.BGRA32: to = System.Drawing.Imaging.PixelFormat.Format32bppArgb; flags = (int)ImageFlags.ColorSpaceRgb; break; default: throw new ArgumentException(String.Format("pixel format {0} not supported", from)); } }
/// <summary> /// Construct a Texture3d, defining the texture extents and the internal format. /// </summary> /// <param name="ctx"> /// A <see cref="GraphicsContext"/> used for creating this Texture. /// </param> /// <param name="width"> /// A <see cref="UInt32"/> that specify the texture width. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specify the texture height. /// </param> /// <param name="depth"> /// A <see cref="UInt32"/> that specify the texture depth. /// </param> /// <param name="format"> /// A <see cref="PixelLayout"/> determining the texture internal format. /// </param> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is zero. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> equals to <see cref="PixelFormat.None"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// Exception thrown if no context is current to the calling thread. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/> or <paramref name="height"/> is greater than /// the maximum allowed for 2D textures. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by current context, and <paramref name="width"/> or <paramref name="height"/> /// is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> public Texture3d(uint width, uint height, uint depth, PixelLayout format) { Create(width, height, depth, format); }
/// <summary> /// Read this GraphicsSurface color buffer. /// </summary> /// <param name="ctx"> /// A <see cref="GraphicsContext"/> /// </param> /// <param name="rBuffer"> /// A <see cref="ReadBufferMode"/> that specify the read buffer where the colors are read from. /// </param> /// <param name="x"> /// A <see cref="Int32"/> that specify the x coordinate of the lower left corder of the rectangle area to read. /// </param> /// <param name="y"> /// A <see cref="Int32"/> that specify the y coordinate of the lower left corder of the rectangle area to read. /// </param> /// <param name="width"> /// A <see cref="Int32"/> that specify the width of the rectangle area to read. /// </param> /// <param name="height"> /// A <see cref="Int32"/> that specify the height of the rectangle area to read. /// </param> /// <param name="pType"> /// A <see cref="PixelLayout"/> which determine the pixel storage of the returned image. /// </param> /// <returns> /// It returns an <see cref="Image"/> representing the current read buffer <paramref name="rBuffer"/>. /// </returns> protected Image ReadBuffer(GraphicsContext ctx, ReadBufferMode rBuffer, uint x, uint y, uint width, uint height, PixelLayout pType) { Image image = null; if ((x + width > Width) || (y + height > Height)) throw new ArgumentException("specified region lies outside the GraphicsSurface"); // Bind for reading BindRead(ctx); // Set for reading Gl.ReadBuffer(rBuffer); // Allocate image holding data read image = new Image(); image.Create(pType, width, height); // Set pixel transfer foreach (int alignment in new int[] { 8, 4, 2, 1 }) { if (image.Stride % alignment == 0) { Gl.PixelStore(PixelStoreParameter.PackAlignment, alignment); break; } } // Grab frame buffer pixels PixelFormat rFormat = Pixel.GetGlFormat(pType); PixelType rType = Pixel.GetPixelType(pType); Gl.ReadPixels((int)x, (int)y, (int)width, (int)height, rFormat, rType, image.ImageBuffer); // Unbind from reading UnbindRead(ctx); return (image); }
/// <summary> /// Check whether the texture extents are compatible with context capabilities. /// </summary> /// <param name="caps"> /// A <see cref="GraphicsCapabilities"/> determining the underlying texture capabilities. /// </param> /// <param name="width"> /// A <see cref="UInt32"/> that specify the texture width. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specify the texture height. /// </param> /// <param name="depth"> /// A <see cref="UInt32"/> that specify the texture depth. /// </param> /// <param name="format"> /// A <see cref="OpenGL.PixelLayout"/> that specify the texture internal format. /// </param> /// <exception cref="ArgumentNullException"> /// Exception throw if <paramref name="caps"/> is null. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="width"/>, <paramref name="height"/> or <paramref name="depth"/> is greater than /// the maximum allowed for the specific texture target. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if NPOT texture are not supported by <paramref name="caps"/>, and <paramref name="width"/>, <paramref name="height"/> /// or <paramref name="depth"/> is not a power-of-two value. /// </exception> /// <exception cref="ArgumentException"> /// Exception thrown if <paramref name="format"/> is not a supported internal format. /// </exception> private void CheckCapabilities(GraphicsCapabilities caps, uint width, uint height, uint depth, PixelLayout format) { if (caps == null) throw new ArgumentNullException("caps"); if (caps.GlExtensions == null) throw new ArgumentException("caps GL extensions not queried", "caps"); if (caps.Limits == null) throw new ArgumentException("caps Limits not queried", "caps"); // Texture maximum size switch (TextureTarget) { case TextureTarget.Texture1d: if (width > caps.Limits.MaxTexture2DSize) throw new ArgumentException(String.Format("width greater than maximum allowed ({0})", caps.Limits.MaxTexture2DSize)); break; case TextureTarget.Texture2d: if (width > caps.Limits.MaxTexture2DSize) throw new ArgumentException(String.Format("width greater than maximum allowed ({0})", caps.Limits.MaxTexture2DSize)); if (height > caps.Limits.MaxTexture2DSize) throw new ArgumentException(String.Format("height greater than maximum allowed ({0})", caps.Limits.MaxTexture2DSize)); break; case TextureTarget.TextureRectangle: if (width > caps.Limits.MaxTextureRectSize) throw new ArgumentException(String.Format("width greater than maximum allowed ({0})", caps.Limits.MaxTextureRectSize)); if (height > caps.Limits.MaxTextureRectSize) throw new ArgumentException(String.Format("height greater than maximum allowed ({0})", caps.Limits.MaxTextureRectSize)); break; case TextureTarget.Texture3d: if (width > caps.Limits.MaxTexture3DSize) throw new ArgumentException(String.Format("width greater than maximum allowed ({0})", caps.Limits.MaxTexture3DSize)); if (height > caps.Limits.MaxTexture3DSize) throw new ArgumentException(String.Format("height greater than maximum allowed ({0})", caps.Limits.MaxTexture3DSize)); if (depth > caps.Limits.MaxTexture3DSize) throw new ArgumentException(String.Format("depth greater than maximum allowed ({0})", caps.Limits.MaxTexture3DSize)); break; case TextureTarget.TextureCubeMap: if (width > caps.Limits.MaxTextureCubeSize) throw new ArgumentException(String.Format("width greater than maximum allowed ({0})", caps.Limits.MaxTextureCubeSize)); if (height > caps.Limits.MaxTextureCubeSize) throw new ArgumentException(String.Format("height greater than maximum allowed ({0})", caps.Limits.MaxTextureCubeSize)); break; default: throw new NotImplementedException("not implemented checks on texture " + GetType()); } // Texture not-power-of-two if (caps.GlExtensions.TextureNonPowerOfTwo_ARB == false) { if (IsPowerOfTwo(width) == false) throw new ArgumentException(String.Format("NPOT texture width not supported (width is {0})", width)); if (IsPowerOfTwo(height) == false) throw new ArgumentException(String.Format("NPOT texture height not supported (height is {0})", height)); if (IsPowerOfTwo(depth) == false) throw new ArgumentException(String.Format("NPOT texture depth not supported (height is {0})", height)); } // Texture internal format if (Pixel.IsSupportedInternalFormat(format) == false) throw new ArgumentException(String.Format("not supported texture internal format {0}", format), "format"); }