title: OpenGL blending creates white border around textures
body: <p>I'm trying to use OpenGL (C++) to render two textures onto a rectangle. I'm having some trouble blending the two of them though.</p>
  
  <p>The first image comes from a .jpg file (<a href="https://learnopengl.com/img/textures/container.jpg" rel="noreferrer">https://learnopengl.com/img/textures/container.jpg</a>).
  This image has no alpha channel.</p>
  
  <p>The second image comes from a .png file (<a href="https://learnopengl.com/img/textures/awesomeface.png" rel="noreferrer">https://learnopengl.com/img/textures/awesomeface.png</a>) and does have an alpha channel.</p>
  
  <p>The problem is when I try to blend the two images, it creates a white border around the transparent image.</p>
  
  <p>I've tried a few different blending modes (as recommended by the OP in this question: <a href="https://stackoverflow.com/questions/7441568/alpha-blending-with-multiple-textures-leaves-colored-border">Alpha blending with multiple textures leaves colored border</a>) but none of them seem to work.</p>
  
  <p>My fragment shader looks like this:</p>
  
  <pre><code>#version 330 core
  out vec4 FragColor;
  
  in vec3 ourColor;
  in vec2 TexCoord;
  
  // texture samplers
  uniform sampler2D texture1;
  uniform sampler2D texture2;
  
  void main()
  {
      // linearly interpolate between both textures
      FragColor = mix(texture(texture1, TexCoord), texture(texture2, TexCoord), 0.5);
  }
  </code></pre>
  
  <p>I have depth testing enabled (doesn't seem to have any effect) and I'm using the following code for setting up my blending:</p>
  
  <pre><code>glEnable(GL_DEPTH_TEST);
  glEnable(GL_BLEND);
  glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  </code></pre>
  
  <p>This is my main render loop:</p>
  
  <pre><code>Rendering::Pipeline pipeline = Rendering::Pipeline("src/GLSL/vertex.glsl", "src/GLSL/fragment.glsl");
  pipeline.load();
  
  //                     Position,               Color,                   Texture Coord.
  //                     (X Y Z)                 (R G B)                  (S T)
  float vertices [32] = { 0.5f,   0.5f,   0.0f,   1.0f,   0.0f,   0.0f,   1.0f, 1.0f, // top right
                          0.5f,   -0.5f,  0.0f,   0.0f,   1.0f,   0.0f,   1.0f, 0.0f, // bottom right
                          -0.5f,  -0.5f,  0.0f,   0.0f,   0.0f,   1.0f,   0.0f, 0.0f, // bottom left
                          -0.5f,  0.5f,   0.0f,   1.0f,   1.0f,   0.0f,   0.0f, 1.0f  };// top left
  
  unsigned int vertexIndices [6] = {  3,  2,  0,
                                      2,  1,  0   };
  
  
  unsigned int vbo;
  unsigned int vao;
  unsigned int ebo;
  
  glGenVertexArrays(1, &amp;vao);
  glGenBuffers(1, &amp;vbo);
  glGenBuffers(1, &amp;ebo);
  
  glBindVertexArray(vao);
  
  glBindBuffer(GL_ARRAY_BUFFER, vbo);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
  
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(vertexIndices), vertexIndices, GL_STATIC_DRAW);
  
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*) 0);
  glEnableVertexAttribArray(0);
  
  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*) (3 * sizeof(float)));
  glEnableVertexAttribArray(1);
  
  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*) (6 * sizeof(float)));
  glEnableVertexAttribArray(2);
  
  unsigned int texture1;
  unsigned int texture2;
  int width;
  int height;
  int numChannels;
  unsigned char* data;
  
  glGenTextures(1, &amp;texture1);
  glBindTexture(GL_TEXTURE_2D, texture1);
  
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  
  data = stbi_load("res/jpg/container.jpg", &amp;width, &amp;height, &amp;numChannels, STBI_rgb);
  
  if (data)
  {
      lTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
      glGenerateMipmap(GL_TEXTURE_2D);
  }
  
  stbi_image_free(data);
  
  glGenTextures(1, &amp;texture2);
  glBindTexture(GL_TEXTURE_2D, texture2);
  
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  
  stbi_set_flip_vertically_on_load(true);
  
  data = stbi_load("res/png/awesomeface.png", &amp;width, &amp;height, &amp;numChannels, STBI_rgb_alpha);
  
  if (data)
  {
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
      glGenerateMipmap(GL_TEXTURE_2D);
  }
  
  stbi_image_free(data);
  
  glUseProgram(pipeline.getProgramId());
  glUniform1i(glGetUniformLocation(pipeline.getProgramId(), "texture1"), 0);
  glUniform1i(glGetUniformLocation(pipeline.getProgramId(), "texture2"), 1);
  
  while (!this-&gt;mQuit)
  {
      this-&gt;counter.start();
  
      InputProcessor::getInstance().processInputs();
  
      if (this-&gt;debugOverlay)
      {
          glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
      }
      else
      {
          glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
      }
  
      glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
      glActiveTexture(GL_TEXTURE0);
      glBindTexture(GL_TEXTURE_2D, texture1);
  
      glActiveTexture(GL_TEXTURE1);
      glBindTexture(GL_TEXTURE_2D, texture2);
  
      pipeline.use();
      glBindVertexArray(vao);
      glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
  
      SDL_GL_SwapWindow(this-&gt;sdlWindow);
  
      this-&gt;counter.stop();
      this-&gt;deltaTime = this-&gt;counter.getDelta();
  }
  
      this-&gt;quit();
  </code></pre>
  
  <p>The issue is most easily observed when passing 0.5 as parameter to the mix() function in the fragment shader. When using 0.0 or 1.0 I get (as expected) only one of the textures.</p>