• Advertisement
  • Popular Tags

  • Popular Now

  • Advertisement
  • Similar Content

    • By Fadey Duh
      Good evening everyone!

      I was wondering if there is something equivalent of  GL_NV_blend_equation_advanced for AMD?
      Basically I'm trying to find more compatible version of it.

      Thank you!
    • By Jens Eckervogt
      Hello guys, 
       
      Please tell me! 
      How do I know? Why does wavefront not show for me?
      I already checked I have non errors yet.
      using OpenTK; using System.Collections.Generic; using System.IO; using System.Text; namespace Tutorial_08.net.sourceskyboxer { public class WaveFrontLoader { private static List<Vector3> inPositions; private static List<Vector2> inTexcoords; private static List<Vector3> inNormals; private static List<float> positions; private static List<float> texcoords; private static List<int> indices; public static RawModel LoadObjModel(string filename, Loader loader) { inPositions = new List<Vector3>(); inTexcoords = new List<Vector2>(); inNormals = new List<Vector3>(); positions = new List<float>(); texcoords = new List<float>(); indices = new List<int>(); int nextIdx = 0; using (var reader = new StreamReader(File.Open("Contents/" + filename + ".obj", FileMode.Open), Encoding.UTF8)) { string line = reader.ReadLine(); int i = reader.Read(); while (true) { string[] currentLine = line.Split(); if (currentLine[0] == "v") { Vector3 pos = new Vector3(float.Parse(currentLine[1]), float.Parse(currentLine[2]), float.Parse(currentLine[3])); inPositions.Add(pos); if (currentLine[1] == "t") { Vector2 tex = new Vector2(float.Parse(currentLine[1]), float.Parse(currentLine[2])); inTexcoords.Add(tex); } if (currentLine[1] == "n") { Vector3 nom = new Vector3(float.Parse(currentLine[1]), float.Parse(currentLine[2]), float.Parse(currentLine[3])); inNormals.Add(nom); } } if (currentLine[0] == "f") { Vector3 pos = inPositions[0]; positions.Add(pos.X); positions.Add(pos.Y); positions.Add(pos.Z); Vector2 tc = inTexcoords[0]; texcoords.Add(tc.X); texcoords.Add(tc.Y); indices.Add(nextIdx); ++nextIdx; } reader.Close(); return loader.loadToVAO(positions.ToArray(), texcoords.ToArray(), indices.ToArray()); } } } } } And It have tried other method but it can't show for me.  I am mad now. Because any OpenTK developers won't help me.
      Please help me how do I fix.

      And my download (mega.nz) should it is original but I tried no success...
      - Add blend source and png file here I have tried tried,.....  
       
      PS: Why is our community not active? I wait very longer. Stop to lie me!
      Thanks !
    • By codelyoko373
      I wasn't sure if this would be the right place for a topic like this so sorry if it isn't.
      I'm currently working on a project for Uni using FreeGLUT to make a simple solar system simulation. I've got to the point where I've implemented all the planets and have used a Scene Graph to link them all together. The issue I'm having with now though is basically the planets and moons orbit correctly at their own orbit speeds.
      I'm not really experienced with using matrices for stuff like this so It's likely why I can't figure out how exactly to get it working. This is where I'm applying the transformation matrices, as well as pushing and popping them. This is within the Render function that every planet including the sun and moons will have and run.
      if (tag != "Sun") { glRotatef(orbitAngle, orbitRotation.X, orbitRotation.Y, orbitRotation.Z); } glPushMatrix(); glTranslatef(position.X, position.Y, position.Z); glRotatef(rotationAngle, rotation.X, rotation.Y, rotation.Z); glScalef(scale.X, scale.Y, scale.Z); glDrawElements(GL_TRIANGLES, mesh->indiceCount, GL_UNSIGNED_SHORT, mesh->indices); if (tag != "Sun") { glPopMatrix(); } The "If(tag != "Sun")" parts are my attempts are getting the planets to orbit correctly though it likely isn't the way I'm meant to be doing it. So I was wondering if someone would be able to help me? As I really don't have an idea on what I would do to get it working. Using the if statement is truthfully the closest I've got to it working but there are still weird effects like the planets orbiting faster then they should depending on the number of planets actually be updated/rendered.
    • By Jens Eckervogt
      Hello everyone, 
      I have problem with texture
      using System; using OpenTK; using OpenTK.Input; using OpenTK.Graphics; using OpenTK.Graphics.OpenGL4; using System.Drawing; using System.Reflection; namespace Tutorial_05 { class Game : GameWindow { private static int WIDTH = 1200; private static int HEIGHT = 720; private static KeyboardState keyState; private int vaoID; private int vboID; private int iboID; private Vector3[] vertices = { new Vector3(-0.5f, 0.5f, 0.0f), // V0 new Vector3(-0.5f, -0.5f, 0.0f), // V1 new Vector3(0.5f, -0.5f, 0.0f), // V2 new Vector3(0.5f, 0.5f, 0.0f) // V3 }; private Vector2[] texcoords = { new Vector2(0, 0), new Vector2(0, 1), new Vector2(1, 1), new Vector2(1, 0) }; private int[] indices = { 0, 1, 3, 3, 1, 2 }; private string vertsrc = @"#version 450 core in vec3 position; in vec2 textureCoords; out vec2 pass_textureCoords; void main(void) { gl_Position = vec4(position, 1.0); pass_textureCoords = textureCoords; }"; private string fragsrc = @"#version 450 core in vec2 pass_textureCoords; out vec4 out_color; uniform sampler2D textureSampler; void main(void) { out_color = texture(textureSampler, pass_textureCoords); }"; private int programID; private int vertexShaderID; private int fragmentShaderID; private int textureID; private Bitmap texsrc; public Game() : base(WIDTH, HEIGHT, GraphicsMode.Default, "Tutorial 05 - Texturing", GameWindowFlags.Default, DisplayDevice.Default, 4, 5, GraphicsContextFlags.Default) { } protected override void OnLoad(EventArgs e) { base.OnLoad(e); CursorVisible = true; GL.GenVertexArrays(1, out vaoID); GL.BindVertexArray(vaoID); GL.GenBuffers(1, out vboID); GL.BindBuffer(BufferTarget.ArrayBuffer, vboID); GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * Vector3.SizeInBytes), vertices, BufferUsageHint.StaticDraw); GL.GenBuffers(1, out iboID); GL.BindBuffer(BufferTarget.ElementArrayBuffer, iboID); GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(indices.Length * sizeof(int)), indices, BufferUsageHint.StaticDraw); vertexShaderID = GL.CreateShader(ShaderType.VertexShader); GL.ShaderSource(vertexShaderID, vertsrc); GL.CompileShader(vertexShaderID); fragmentShaderID = GL.CreateShader(ShaderType.FragmentShader); GL.ShaderSource(fragmentShaderID, fragsrc); GL.CompileShader(fragmentShaderID); programID = GL.CreateProgram(); GL.AttachShader(programID, vertexShaderID); GL.AttachShader(programID, fragmentShaderID); GL.LinkProgram(programID); // Loading texture from embedded resource texsrc = new Bitmap(Assembly.GetEntryAssembly().GetManifestResourceStream("Tutorial_05.example.png")); textureID = GL.GenTexture(); GL.BindTexture(TextureTarget.Texture2D, textureID); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)All.Linear); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)All.Linear); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, texsrc.Width, texsrc.Height, 0, PixelFormat.Bgra, PixelType.UnsignedByte, IntPtr.Zero); System.Drawing.Imaging.BitmapData bitmap_data = texsrc.LockBits(new Rectangle(0, 0, texsrc.Width, texsrc.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppRgb); GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, 0, texsrc.Width, texsrc.Height, PixelFormat.Bgra, PixelType.UnsignedByte, bitmap_data.Scan0); texsrc.UnlockBits(bitmap_data); GL.Enable(EnableCap.Texture2D); GL.BufferData(BufferTarget.TextureBuffer, (IntPtr)(texcoords.Length * Vector2.SizeInBytes), texcoords, BufferUsageHint.StaticDraw); GL.BindAttribLocation(programID, 0, "position"); GL.BindAttribLocation(programID, 1, "textureCoords"); } protected override void OnResize(EventArgs e) { base.OnResize(e); GL.Viewport(0, 0, ClientRectangle.Width, ClientRectangle.Height); } protected override void OnUpdateFrame(FrameEventArgs e) { base.OnUpdateFrame(e); keyState = Keyboard.GetState(); if (keyState.IsKeyDown(Key.Escape)) { Exit(); } } protected override void OnRenderFrame(FrameEventArgs e) { base.OnRenderFrame(e); // Prepare for background GL.Clear(ClearBufferMask.ColorBufferBit); GL.ClearColor(Color4.Red); // Draw traingles GL.EnableVertexAttribArray(0); GL.EnableVertexAttribArray(1); GL.BindVertexArray(vaoID); GL.UseProgram(programID); GL.BindBuffer(BufferTarget.ArrayBuffer, vboID); GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 0, IntPtr.Zero); GL.ActiveTexture(TextureUnit.Texture0); GL.BindTexture(TextureTarget.Texture3D, textureID); GL.BindBuffer(BufferTarget.ElementArrayBuffer, iboID); GL.DrawElements(BeginMode.Triangles, indices.Length, DrawElementsType.UnsignedInt, 0); GL.DisableVertexAttribArray(0); GL.DisableVertexAttribArray(1); SwapBuffers(); } protected override void OnClosed(EventArgs e) { base.OnClosed(e); GL.DeleteVertexArray(vaoID); GL.DeleteBuffer(vboID); } } } I can not remember where do I add GL.Uniform2();
    • By Jens Eckervogt
      Hello everyone
      For @80bserver8 nice job - I have found Google search. How did you port from Javascript WebGL to C# OpenTK.?
      I have been searched Google but it shows f***ing Unity 3D. I really want know how do I understand I want start with OpenTK But I want know where is porting of Javascript and C#?
       
      Thanks!
  • Advertisement
  • Advertisement
Sign in to follow this  

OpenGL Transparency using glDrawPixels

This topic is 3543 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Does OpenGL use pre-multiplied alpha? I can't find anything about it in the red book or even on google but i have been using the SOIL library with my game for a while now an i use it with the flag SOIL_FLAG_MULTIPLY_ALPHA. When i use it without this some of my images have while where it should be transparent. That was for my GUI, now i am up to writing the code for the game maps and (for various reasons) i am using raw pixel data instead of GL textures. But i don't know if i need to pre-multiply the pixel data. I tried with and without and it definitely seems to use pre-multiplied alpha. But the background of the image is still black. I am drawing the pixel data over the top of a textured quad and the image should show the texture through the transparent parts. Well, i'll just show you... The blend function is (GL_ONE, GL_ONE_MINUS_SRC_ALPHA). [Edited by - XTAL256 on July 27, 2008 9:50:09 PM]

Share this post


Link to post
Share on other sites
Advertisement
Quote:
Original post by XTAL256
Does OpenGL use pre-multiplied alpha?

No, it doesn't.

As to why you don't get transparency, there can be lots of reasons - blending not enabled, alpha channel not transferred, incorrectly configured pixel transfer pipeline, etc. You don't provide enough information to proceed any further than pure speculation.

Share this post


Link to post
Share on other sites
Gl uses whatever blend mode you tell it to. By looking at your blend function it seems like you are using pre-multiplied alpha. Make sure you have all relevant alpha options turned on, and that you are using alpha format for your texture.

Share this post


Link to post
Share on other sites
Oh yeah, I didn't notice that you use a strange blending mode.

The best and most straightforward way is to use (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA). Your alpha value then simply represents opacity.

Share this post


Link to post
Share on other sites
Quote:
Original post by Yann L
Oh yeah, I didn't notice that you use a strange blending mode.

The best and most straightforward way is to use (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA). Your alpha value then simply represents opacity.



That's not "the best", it has all sorts of problems compared to premultiplied: http://home.comcast.net/~tom_forsyth/blog.wiki.html#%5B%5BPremultiplied%20alpha%5D%5D

Both are equally straightforward as they involve setting the blending mode.

I'm guessing previous posters are correct and part of the state is missing (i.e blending disabled, etc).

Share this post


Link to post
Share on other sites
Quote:
Original post by raigan
That's not "the best", it has all sorts of problems compared to premultiplied: http://home.comcast.net/~tom_forsyth/blog.wiki.html#%5B%5BPremultiplied%20alpha%5D%5D

And premultiplied alpha has even more problems that (conveniently) aren't mentioned in that article. Standard alpha blending is the 'best' in the sense that it is the easiest, most intuitive and most flexible method that is achievable with todays' non-programmable blending stages.

Premultiplied alpha is in no way more 'correct' than standard alpha blending. Physically, they're both entirely wrong. However, while premultiplied alpha can have its uses in image composition (keep in mind that it was originally designed to speed up CPU blending !), it is often more incorrect than standard alpha blending when introducing concepts such as HDR, non-linear blending or the dreaded HDR-MSAA-Tonemapping combo. And with modern programmable pipelines, what do you call 'pre'-multiplied alpha anyway ? When does the post-multiply become a pre-multiply ? It doesn't really make any sense.

This article cites the whole DXT compression deal as an advantage for premultiplied alpha. That is entirely incorrect. This is strictly a question about the behaviour of lossy compression algorithms regarding to edge cases, especially colour values that are totally transparent. Premultiplying them with alpha is in no way a guarantee to increase DXT compression quality. Infact, while it might improve quality on some images, it can seriously degrade quality on others. And beside doing nothing (ie. leaving the colour values as-is) or multiplying with alpha, there are a whole pile of other techniques that consistently improve quality on almost all cases, and that have absolutely nothing to do with premultiplied alpha.

Whether or not this is what the OP is after is another question. I have personally never felt the need for PM alpha. If you don't need physically correct blending, then standard alpha is perfectly fine and gives you the option to modify transparency on the fly. If you need physically correct transparency, then you can't use the standard blending pipeline anyway.

Share this post


Link to post
Share on other sites
I'm kind of a n00b when it comes to OpenGL. I am just making this game as a hobby, i never took any courses on OGL and i haven't read all of the red book. I know the basics of OGL and i even made a Windows Media Player visualisation using it but i never understood how to do alpha blending. When i tried the mode that i thought would work, i just got black where it should have been transparent. So when i started making my game i used SOIL for loading images and for reasons i can no longer remember i used GL_ONE, GL_ONE_MINUS_SRC_ALPHA as the blend mode. I just set blend mode to what you said (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA without pre-multiplied alpha) and it works just the same, so i'll use that.
But i still can't get the map to draw properly. I worked out (before i posted this) that i needed to disable textures before drawing pixels but do i also need to turn off alpha blending? Because it still doesn't work if i do. I know it's hard to help me if i don't provide much info but i don't know where the problem is. Here is some of the code:

/// Map.h /////////////////////////
class Map {
public:
static Vector<Map*> maps; // List of all Maps
static void loadMaps(); // Load Maps from Map directory

public:
bool isCreated; // If the map has been created
String name, description;
String dir; // Directory where map data is
Image* preview; // Preview image to show in GUI
int width, height; // Size of map (px)
Rect view; // Area in view on screen
int maxPlayers; // Maximum number of players
Image* background; // Background image
int bgTileMode; // Whether to tile or stretch background
unsigned char* image; // Map image
unsigned char* terrain; // Terrain map

Map() : isCreated(false) {}
~Map();
void load(String &filename);
void create();
void distroy();
void draw();
};

/// Map.cpp ///////////////////////
void Map::draw() {
drawImage(background, 0, 0, 800, 450); // Draws a texture mapped quad with background image on it
glDisable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
glRasterPos2i(100, 300); // These values are just for debugging
glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_BYTE, image);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
}


The image is made up of smaller tile images but basically the image data is loaded using SOIL_load_image (see SOIL docs). When i don't use pre-multiplied alpha (and using the blend mode you guys suggested) the transparent areas are white but when i do use it the transparent areas are black, which i assume is transparent because the background is black.

Share this post


Link to post
Share on other sites
Quote:
Original post by Yann L
And premultiplied alpha has even more problems that (conveniently) aren't mentioned in that article. Standard alpha blending is the 'best' in the sense that it is the easiest, most intuitive and most flexible method that is achievable with todays' non-programmable blending stages.



Having to resort to complex, ad-hoc pre-processing in order to avoid weird halos around the edges of transparent textures is what makes the standard method awkward, non-intuitive (especially for beginners) and pretty damn stupid: http://www.robinwood.com/Catalog/Technical/SL-Tuts/SLPages/WhiteHalo2.html

Compression aside, what are the "even more" problems with PM?

Share this post


Link to post
Share on other sites
Quote:
Original post by raigan
Quote:
Original post by Yann L
And premultiplied alpha has even more problems that (conveniently) aren't mentioned in that article. Standard alpha blending is the 'best' in the sense that it is the easiest, most intuitive and most flexible method that is achievable with todays' non-programmable blending stages.



Having to resort to complex, ad-hoc pre-processing in order to avoid weird halos around the edges of transparent textures is what makes the standard method awkward, non-intuitive (especially for beginners) and pretty damn stupid: http://www.robinwood.com/Catalog/Technical/SL-Tuts/SLPages/WhiteHalo2.html

That's a photoshop/content creation issue that has nothing to do with pre-multiplied vs. non-pre-multiplied. PEBKAC.

Share this post


Link to post
Share on other sites
I guess I wasn't clear -- this image on that page specifically shows the sort of thing you have to do (either via the plugin on that page OR your own pre-process) to make sure that fully transparent pixels are colored to avoid haloing: http://www.robinwood.com/Catalog/Technical/SL-Tuts/SLGraphics/Halo/Halo12-Solidified.jpg

Color from fully transparent pixels being "pulled in" by texture filtering isn't a Photoshop/content creation issue, it's a direct result of the non-PM blending formula.

Another way to look at it is that non-PM will always lerp both color and alpha channels at the same time, which is not what you want at the edges of transparencies -- you want the alpha to lerp to 0 while the color stays constant. This is impossible to achieve with non-PM blending, and pre-processing images to "bleed" the correct color into fully transparent texels is a common work-around, not a proper solution.

PM lets you avoid this problem, which is the main reason to use it IMHO; I thought this was a well-known issue, or else I would have been more specific with the example link.. it was just the first one I came across.

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement