十四、混合

最新推荐文章于 2024-01-20 15:33:42 发布
最新推荐文章于 2024-01-20 15:33:42 发布
阅读量594 收藏
点赞数
分类专栏： OpenGL 安卓学习 文章标签： opengles混合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zw1996/article/details/131074701
版权

第一部分 概念：

1) 引入

OpenGL ES 混合本质上是将 2 个片元的颜色进行调和，产生一个新的颜色。OpenGL ES 混合发生在片元通过各项测试之后，准备进入帧缓冲区的片元和原有的片元按照特定比例加权计算出最终片元的颜色值，不再是新（源）片元直接覆盖缓冲区中的（目标）片元。

在这里插入图片描述

2）应用

启用 OpenGL ES 混合使用 需要在绘画前启动glEnable(GL_BLEND);。

然后通过 void glBlendFunc(GLenum sfactor, GLenum dfactor); 设置混合的方式，其中 sfactor 表示源因子，dfactor 表示目标因子。

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// GL_SRC_ALPHA 表示源因子取值为源颜色的 alpha
// GL_ONE_MINUS_SRC_ALPHA 表示目标因子取值为 1- alpha（源颜色的 alpha）

// 操作符默认为 GL_FUNC_ADD ，即加权相加。
// 混合公式变成了 源颜色向量 × alpha + 目标颜色向量 × （1- alpha）

在这里插入图片描述

默认的操作符是加号，我们也可以通过void glBlendEquation(GLenum mode)接口来自定义设置。

GL_FUNC_ADD：默认的，彼此元素相加

GL_FUNC_SUBTRACT：彼此元素相减

GL_FUNC_REVERSE_SUBTRACT：彼此元素相减，但顺序相反

GL_MIN：混合结果的 4 个通道值分别取 2 元素中 4 个通道较小的值

GL_MAX：混合结果的 4 个通道值分别取 2 元素中 4 个通道较大的值

glBlendFuncSeperate为 RGB 和 alpha 通道各自设置不同的混合因子

//对 RGB 和 Alpha 分别设置 BLEND 函数

void glBlendFuncSeparate(GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha);

glBlendFuncSeperate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,GL_ONE, GL_ZERO);
上面就表示
混合结果颜色 RGB 向量 = 源颜色 RGB 向量 × alpha + 目标颜色 RGB 向量 × (1- alpha);
混合结果颜色 alpha = 源颜色 alpha × 1 + 目标颜色 alpha × 0;

这个也是默认为+号，但是可以通过glBlendEquationSeparate为 RGB 和 alpha 通道各自设置不同操作符。void glBlendEquationSeparate(GLenum modeRGB,GLenum modeAlpha);

另外需要格外注意的是，开启混合和深度测试绘制透明物体时，需要遵循物体距观察者（Camera）的距离，由远到近开始绘制，这样可以避免由于深度测试开启后（在透明物体后面）丢弃片元造成的奇怪现象。

第二部分 实践：

1）java部分

java部分在绘制部分都是跟之前一致的，只是因为混合使用到了图片的RGBA中A的维度，需要将32位的png图片在java端转换为具体的RGBA数据传递到JNI去。

NativeImpl.java

public class NativeImpl {
	。。。。
	//多出这个native接口
	public static native void native_SetImageDataWithIndex(int index, int width,int height, byte[] byteArray);
}

MyGLSurfaceView.java

public class MyGLSurfaceView extends GLSurfaceView implements ScaleGestureDetector.OnScaleGestureListener{
	 public MyGLSurfaceView(Context context) {
	 	...
	 	
	 	//开始的时候就把内容主动传递到
	 	loadRGBAImage(R.drawable.board_texture,0);
        loadRGBAImage(R.drawable.floor,1);
        loadRGBAImage(R.drawable.window,2);
	 }
	private Bitmap loadRGBAImage(int resId, int index) {
        InputStream is = this.getResources().openRawResource(resId);
        Bitmap bitmap;
        try {
            bitmap = BitmapFactory.decodeStream(is);
            if (bitmap != null) {
                int bytes = bitmap.getByteCount();
                ByteBuffer buf = ByteBuffer.allocate(bytes);
                bitmap.copyPixelsToBuffer(buf);
                byte[] byteArray = buf.array();
                renderer.setImageDataWithIndex(index, bitmap.getWidth(), bitmap.getHeight(), byteArray);
            }
        }
        finally
        {
            try
            {
                is.close();
            }
            catch(IOException e)
            {
                e.printStackTrace();
            }
        }
        return bitmap;
    }
    
    
    ...
    
    private class MyRenderer implements Renderer {
    	...
    	public void setImageDataWithIndex(int index, int width, int height, byte[] bytes) {
            NativeImpl.native_SetImageDataWithIndex(index, width, height, bytes);
        }
    }
}

2）C++部分

NativeGL.cpp

多出
std::vector<struct ImageTyep> vcImage;
/*
 * Class:     com_example_nineblending_native_SetImageDataWithIndex
 * Method:    native_SetImageDataWithIndex
 * Signature: (III[B)V
 */
JNIEXPORT void JNICALL native_SetImageDataWithIndex(JNIEnv *env, jobject instance, jint index, jint width, jint height, jbyteArray byteArray)
{
	struct ImageTyep itype;
	int len = env->GetArrayLength (byteArray);
	uint8_t* buf = new uint8_t[len];
	env->GetByteArrayRegion(byteArray, 0, len, reinterpret_cast<jbyte*>(buf));
	itype.data = buf;
	itype.width =width;
	itype.height = height;
	vcImage.push_back(itype);
	LOGD("native_SetImageDataWithIndex  width=%d height =  height", width, height);
	//env->DeleteLocalRef(byteArray);
}

Blending.h

//
// Created by CreatWall_zhouwen on 2023/5/15.
//

#ifndef NINEBLENDING_BLENDING_H
#define NINEBLENDING_BLENDING_H
#include <GLES3/gl3.h>
#include <detail/type_mat.hpp>
#include <detail/type_mat4x4.hpp>
#include <vector>
#include <map>
#include "Const.h"
#define MATH_PI 3.1415926535897932384626433832802
#define RENDER_IMG_NUM 3
class Blending {
public:
    Blending();
    ~Blending();
    void CreateProgram(const char *ver, const char *frag);
    void Draw();
    void getTexturedata(std::vector<struct ImageTyep> vcImagetemp);
    static Blending* GetInstance();
    static void DestroyInstance();
    void UpdateTransformMatrix(float rotateX, float rotateY, float scaleX, float scaleY);
    void UpdateMatrix(glm::mat4 &mvpMatrix, int angleXRotate, int angleYRotate, float scale, glm::vec3 transVec3, float ratio);
    void OnSurfaceChanged(int width, int height);
private:
    GLuint program;
    GLuint vertexShaderHandle;
    GLuint fragShaderHandle;

    GLuint m_TextureIds[RENDER_IMG_NUM];
    GLint m_SamplerLoc;
    GLint m_MVPMatLoc;

    GLuint m_VaoIds[3];
    GLuint m_VboIds[3];
    std::vector<struct ImageTyep> m_vcImage;
    glm::mat4 m_MVPMatrix;

    std::vector<glm::vec3> windowsTrans;
    std::map<GLfloat, glm::vec3> sorted;

    int m_AngleX;
    int m_AngleY;
    int Srceenwidth;
    int Srceenheight;
};


#endif //NINEBLENDING_BLENDING_H

Blending.cpp

//
// Created by CreatWall_zhouwen on 2023/5/15.
//

#include "Blending.h"
#include "Util.h"
#include "GLUtil.h"
#include <gtc/matrix_transform.hpp>
Blending* m_pContext = nullptr;
#define TAG "DRAWTEXTURE"
GLfloat boxVertices[] = {
      //position            //texture coord
      -0.5f, -0.5f, -0.5f,   0.0f, 0.0f,
      0.5f, -0.5f, -0.5f,   1.0f, 0.0f,
      0.5f,  0.5f, -0.5f,   1.0f, 1.0f,
      0.5f,  0.5f, -0.5f,   1.0f, 1.0f,
      -0.5f,  0.5f, -0.5f,   0.0f, 1.0f,
      -0.5f, -0.5f, -0.5f,   0.0f, 0.0f,

      -0.5f, -0.5f, 0.5f,    0.0f, 0.0f,
      0.5f, -0.5f, 0.5f,    1.0f, 0.0f,
      0.5f,  0.5f, 0.5f,    1.0f, 1.0f,
      0.5f,  0.5f, 0.5f,    1.0f, 1.0f,
      -0.5f,  0.5f, 0.5f,    0.0f, 1.0f,
      -0.5f, -0.5f, 0.5f,    0.0f, 0.0f,

      -0.5f,  0.5f,  0.5f,   1.0f, 0.0f,
      -0.5f,  0.5f, -0.5f,   1.0f, 1.0f,
      -0.5f, -0.5f, -0.5f,   0.0f, 1.0f,
      -0.5f, -0.5f, -0.5f,   0.0f, 1.0f,
      -0.5f, -0.5f,  0.5f,   0.0f, 0.0f,
      -0.5f,  0.5f,  0.5f,   1.0f, 0.0f,

      0.5f,  0.5f,  0.5f,   1.0f, 0.0f,
      0.5f,  0.5f, -0.5f,   1.0f, 1.0f,
      0.5f, -0.5f, -0.5f,   0.0f, 1.0f,
      0.5f, -0.5f, -0.5f,   0.0f, 1.0f,
      0.5f, -0.5f,  0.5f,   0.0f, 0.0f,
      0.5f,  0.5f,  0.5f,   1.0f, 0.0f,

      -0.5f, -0.5f, -0.5f,   0.0f, 1.0f,
      0.5f, -0.5f, -0.5f,   1.0f, 1.0f,
      0.5f, -0.5f,  0.5f,   1.0f, 0.0f,
      0.5f, -0.5f,  0.5f,   1.0f, 0.0f,
      -0.5f, -0.5f,  0.5f,   0.0f, 0.0f,
      -0.5f, -0.5f, -0.5f,   0.0f, 1.0f,

      -0.5f, 0.5f, -0.5f,    0.0f, 1.0f,
      0.5f, 0.5f, -0.5f,    1.0f, 1.0f,
      0.5f, 0.5f,  0.5f,    1.0f, 0.0f,
      0.5f, 0.5f,  0.5f,    1.0f, 0.0f,
      -0.5f, 0.5f,  0.5f,    0.0f, 0.0f,
      -0.5f, 0.5f, -0.5f,    0.0f, 1.0f,
};

GLfloat flatVertices[] = {
      5.0f, -0.5f,  5.0f,  2.0f,  0.0f,
      -5.0f, -0.5f,  5.0f,  0.0f,  0.0f,
      -5.0f, -0.5f, -5.0f,  0.0f,  2.0f,

      5.0f, -0.5f,  5.0f,  2.0f,  0.0f,
      -5.0f, -0.5f, -5.0f,  0.0f,  2.0f,
      5.0f, -0.5f, -5.0f,  2.0f,  2.0f
};

GLfloat windowVertices[] = {
      0.0f,  0.5f,  0.0f,  0.0f,  0.0f,
      0.0f, -0.5f,  0.0f,  0.0f,  1.0f,
      1.0f, -0.5f,  0.0f,  1.0f,  1.0f,

      0.0f,  0.5f,  0.0f,  0.0f,  0.0f,
      1.0f, -0.5f,  0.0f,  1.0f,  1.0f,
      1.0f,  0.5f,  0.0f,  1.0f,  0.0f
};

Blending::Blending() {
    m_SamplerLoc = GL_NONE;
   m_MVPMatLoc = GL_NONE;

   m_AngleX = 0;
   m_AngleY = 0;
   Srceenwidth =  1080;
   Srceenheight = 2115;
}

Blending::~Blending() {

}

void Blending::CreateProgram(const char *ver, const char *frag) {
   LOGD("CreateProgram Enter");
   // 编译链接用于离屏渲染的着色器程序
   program = CreateGLProgram(ver, frag, vertexShaderHandle, fragShaderHandle);
   if (program == GL_NONE)
   {
      LOGD("FBOSample::Init m_ProgramObj == GL_NONE");
      return;
   }
   LOGD("CreateGLProgram Success");
   m_SamplerLoc = glGetUniformLocation(program, "s_TextureMap");
   m_MVPMatLoc = glGetUniformLocation(program, "u_MVPMatrix");
   //创建VBO
   glGenBuffers(3, m_VboIds);
   glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[0]);
   glBufferData(GL_ARRAY_BUFFER, sizeof(boxVertices), boxVertices, GL_STATIC_DRAW);

   glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[1]);
   glBufferData(GL_ARRAY_BUFFER, sizeof(flatVertices), flatVertices, GL_STATIC_DRAW);

   glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[2]);
   glBufferData(GL_ARRAY_BUFFER, sizeof(windowVertices), windowVertices, GL_STATIC_DRAW);

   //创建VAO并绑定VBO
   glGenVertexArrays(3, m_VaoIds);

   glBindVertexArray(m_VaoIds[0]);
   glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[0]);
   glEnableVertexAttribArray(0);
   glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (const void *) 0);
   glEnableVertexAttribArray(1);
   glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (const void *) (3* sizeof(GLfloat)));
   glBindBuffer(GL_ARRAY_BUFFER, GL_NONE);
   glBindVertexArray(GL_NONE);

   glBindVertexArray(m_VaoIds[1]);
   glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[1]);
   glEnableVertexAttribArray(0);
   glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (const void *) 0);
   glEnableVertexAttribArray(1);
   glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (const void *) (3* sizeof(GLfloat)));
   glBindBuffer(GL_ARRAY_BUFFER, GL_NONE);
   glBindVertexArray(GL_NONE);

   glBindVertexArray(m_VaoIds[2]);
   glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[2]);
   glEnableVertexAttribArray(0);
   glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (const void *) 0);
   glEnableVertexAttribArray(1);
   glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (const void *) (3* sizeof(GLfloat)));
   glBindBuffer(GL_ARRAY_BUFFER, GL_NONE);
   glBindVertexArray(GL_NONE);

   //创建纹理并绑定数据
   glGenTextures(RENDER_IMG_NUM, m_TextureIds);
   for (int i = 0; i < RENDER_IMG_NUM; ++i)
   {
      glActiveTexture(GL_TEXTURE0 + i);
      glBindTexture(GL_TEXTURE_2D, m_TextureIds[i]);
      glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
      glTexParameterf(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);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_vcImage[i].width, m_vcImage[i].height, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_vcImage[i].data);
      LOGD("width = %d, height = %d",m_vcImage[i].width, m_vcImage[i].height);
      glBindTexture(GL_TEXTURE_2D, GL_NONE);
   }

    //布局参数
    windowsTrans.push_back(glm::vec3(-1.5f,  0.0f, -0.48f));
    windowsTrans.push_back(glm::vec3( 1.5f,  0.0f,  0.51f));
    windowsTrans.push_back(glm::vec3( 0.0f,  0.0f,  0.7f));
    windowsTrans.push_back(glm::vec3(-0.3f,  0.0f, -2.3f));
    windowsTrans.push_back(glm::vec3( 0.5f,  0.0f, -0.6f));
    for (GLuint i = 0; i < windowsTrans.size(); i++)
    {
        GLfloat distance = std::sqrt(std::pow(windowsTrans[i].x - 0.5f, 2.0f) + std::pow(windowsTrans[i].y - 1.0f, 2.0f) + std::pow(windowsTrans[i].z - 3.0f, 2.0f));
        sorted[distance] = windowsTrans[i];
    }
}

void Blending::Draw() {
   float ratio = (float)Srceenwidth / Srceenheight;
   glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
   glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glEnable(GL_DEPTH_TEST);//开启深度测试
   glEnable(GL_BLEND);//开启混合
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);//源颜色向量 × alpha + 目标颜色向量 × （1- alpha）

   glUseProgram(program);

   glBindVertexArray(m_VaoIds[0]);
   // Bind the RGBA map
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, m_TextureIds[0]);
   glUniform1i(m_SamplerLoc, 0);

   UpdateMatrix(m_MVPMatrix, 0, 0, 1.0,  glm::vec3(-1.0f, 0.0f, -1.0f), ratio);
   glUniformMatrix4fv(m_MVPMatLoc, 1, GL_FALSE, &m_MVPMatrix[0][0]);
   glDrawArrays(GL_TRIANGLES, 0, 36);

   UpdateMatrix(m_MVPMatrix, 0, 0, 1.0,  glm::vec3(2.0f, 0.0f, 0.0f), ratio);
   glUniformMatrix4fv(m_MVPMatLoc, 1, GL_FALSE, &m_MVPMatrix[0][0]);
   glDrawArrays(GL_TRIANGLES, 0, 36);

   glBindVertexArray(0);

   glBindVertexArray(m_VaoIds[1]);
   // Bind the RGBA map
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, m_TextureIds[1]);
   glUniform1i(m_SamplerLoc, 0);

   UpdateMatrix(m_MVPMatrix, 0, 0, 1.0, glm::vec3(0.0f,  0.0f,  0.0f), ratio);
   glUniformMatrix4fv(m_MVPMatLoc, 1, GL_FALSE, &m_MVPMatrix[0][0]);
   glDrawArrays(GL_TRIANGLES, 0, 6);
   glBindVertexArray(0);

   glBindVertexArray(m_VaoIds[2]);
   // Bind the RGBA map
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, m_TextureIds[2]);
   glUniform1i(m_SamplerLoc, 0);

   for (auto it = sorted.rbegin(); it != sorted.rend(); ++it)
   {
      UpdateMatrix(m_MVPMatrix, 0, 0 , 1.0, it->second, ratio);
      glUniformMatrix4fv(m_MVPMatLoc, 1, GL_FALSE, &m_MVPMatrix[0][0]);
      glDrawArrays(GL_TRIANGLES, 0, 6);
   }

   glBindVertexArray(0);

   glDisable(GL_DEPTH_TEST);
   glDisable(GL_BLEND);
}

void Blending::getTexturedata(std::vector<struct ImageTyep> vcImagetemp) {
   m_vcImage = vcImagetemp;
}

Blending *Blending::GetInstance() {
   if (m_pContext == nullptr)
   {
      m_pContext = new Blending();
   }
   return m_pContext;
}

void Blending::DestroyInstance() {
   if (m_pContext)
   {
      delete m_pContext;
      m_pContext = nullptr;
   }
}

void Blending::UpdateTransformMatrix(float rotateX, float rotateY, float scaleX, float scaleY) {
   m_AngleX = static_cast<int>(rotateX);
   m_AngleY = static_cast<int>(rotateY);
}

void Blending::UpdateMatrix(glm::mat4 &mvpMatrix, int angleXRotate, int angleYRotate, float scale,
                            glm::vec3 transVec3, float ratio) {
   LOGD("BlendingSample::UpdateMatrix angleX = %d, angleY = %d, ratio = %f", angleXRotate,
         angleYRotate, ratio);
   angleXRotate = angleXRotate % 360;
   angleYRotate = angleYRotate % 360;

   //转化为弧度角
   float radiansX = static_cast<float>(MATH_PI / 180.0f * angleXRotate);
   float radiansY = static_cast<float>(MATH_PI / 180.0f * angleYRotate);


   // Projection matrix
   //glm::mat4 Projection = glm::ortho(-ratio, ratio, -1.0f, 1.0f, 0.0f, 100.0f);
   //glm::mat4 Projection = glm::frustum(-ratio, ratio, -1.0f, 1.0f, 4.0f, 100.0f);
   glm::mat4 Projection = glm::perspective(45.0f, ratio, 0.1f, 100.f);

   // View matrix
   glm::mat4 View = glm::lookAt(
         glm::vec3(0.5, 1, 3), // Camera is at (0,0,1), in World Space
         glm::vec3(0, 0, 0), // and looks at the origin
         glm::vec3(0, 1, 0)  // Head is up (set to 0,-1,0 to look upside-down)
   );

   // Model matrix
   glm::mat4 Model = glm::mat4(1.0f);
   Model = glm::scale(Model, glm::vec3(scale, scale, scale));
   Model = glm::rotate(Model, radiansX, glm::vec3(1.0f, 0.0f, 0.0f));
   Model = glm::rotate(Model, radiansY, glm::vec3(0.0f, 1.0f, 0.0f));
   Model = glm::translate(Model, transVec3);

   mvpMatrix = Projection * View * Model;
}

void Blending::OnSurfaceChanged(int width, int height) {
   Srceenwidth = width;
   Srceenheight = height;
   LOGD("OnSurfaceChanged Srceenwidth = %d, Srceenheight = %d, ratio = %f", Srceenwidth,Srceenheight);
}

#

卖酒的小码农
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenGLES glBlendFunc 的使用
Philm_iOS的博客
08-14 972
OpenGLES glBlendFunc 的使用 在OpenGL里做颜色混合一般有两种方式，一种是将要混合的纹理都传入Fragment Shader，在shader里实现算法完成混合，一种就是利用OpenGL渲染管线最后的blending阶段自动对源色和底色进行混合。 在Fragment Shader手动实现混合算法比较自由，我们可以自定义一些混合方法，实现一些OpenGL自带混合模式无法实现...
7、混合开发
小伙伴的博客
04-08 740
文章目录 文章目录框架简介视频介绍框架特点数量多平台能力性能优秀生态丰富学习成本开发成本功能架构跨平台样例项目模板开发工具版本管理模板结构apollo配置创建账号账号赋权修改配置首次启动框架指南控件组件基础组件扩展组件脚本组件概述ajax访问组件apollo访问组件版本管理组件样式组件页面组件关于配置组件资源组件界面图标应用图标启动页启动组件main.js其它项目发布基础配置图标配置启动图配置其它...
glBlendFunc()函数的使用
Qinhaifu的博客
08-29 7862
原文链接：http://blog.chinaunix.net/uid-20622737-id-2850251.html glBlendFunc();–混合 OpenGL会把源颜色和目标颜色各自取出，并乘以一个系数（源颜色乘以的系数称为“源因子”，目标颜色乘以的系数称为“目标因子”），然后相加，这样就得到了新的颜色。 （也可以不是相加，新版本的OpenGL可以设置运算方式，包括加、减、取两者中较大的...
颜色混合opengl--glBlendFunc函数
sunnytina的专栏
08-30 799
混合是什么呢？混合就是把两种颜色混在一起。具体一点，就是把某一像素位置原来的颜色和将要画上去的颜色，通过某种方式混在一起，从而实现特殊的效果。 假设我们需要绘制这样一个场景：透过红色的玻璃去看绿色的物体，那么可以先绘制绿色的物体，再绘制红色玻璃。在绘制红色玻璃的时候，利用“混合”功能，把将要绘制上去的红色和原来的绿色进行混合，于是得到一种新的颜色，看上去就好像玻璃是半透明的。 要使用OpenG
OpenGL学习二十七：混合
StarFlex
01-21 877
混合步骤： 1.设置混合模式 2.启用混合 glColor4f(1.0f,1.0f,1.0f,0.5f); // 全亮度， 50% Alpha 混合 glBlendFunc(GL_SRC_ALPHA,GL_ONE); // 基于源象素alpha通道值的半透明混合函数 glEnable(GL_BLEND); // 打开混合 OpenGL 会把源颜色和目标颜色各自取出（源颜色认
Opengl glBlendFunc,颜色混合公式，FrameBuffer混合颜色不正确，预乘alpha总结
m0_58186648的博客
01-20 500
Opengl glBlendFunc,颜色混合公式，FrameBuffer混合颜色不正确，预乘alpha总结
OpenGL 颜色混合、图元的反走样（五）
TanJiaXiang的博客
12-18 798
1、颜色混合   使用混合的原因： 我们把OpenGL渲染时会把颜⾊值存在颜⾊缓存区中，每个⽚段的深度值也是放在深度缓冲区。当深度缓冲区被关闭时，新的颜⾊将简单的覆盖原来颜⾊缓存区存在的颜⾊值；当深度缓冲区再次打开时，新的颜⾊⽚段只是当它们⽐原来的值更接近邻近的裁剪平⾯才会替换原来的颜⾊⽚段。 那么如果开启深度测试后，当出现2个重叠的图层情况，有⼀个图层是半透明的，另⼀个图层是⾮半透明的，那么此时就不能进⾏单纯的⽐较深度值，然后进⾏覆盖。⽽是需要将2个图层的颜⾊进⾏计算后得到应该显示颜色，.
混合开发
qq_45271323的博客
04-08 2386
混合开发三类App: 一. NativeApp(原生APP) ​ 纯工具类APP ​ 特点？ ​ 开发：由Native人员进行开发的 安卓（Android） 苹果（IOS） ​ 语言：Android(Java+XML) IOS（Objective-c / Swift + XML） ​ 更新维护：版本更新、打补丁包 都得需要用户从app store里面进行下载 ...
2021年青岛版五四制三年级数学练习十四 混合运算数学知识点.doc
10-14
混合运算是指在一个数学表达式中同时包含加、减、乘、除四种基本运算，需要按照一定的运算顺序来解决问题。 1. **混合运算的法则** - 首先，了解运算顺序至关重要。通常遵循的顺序是先乘除后加减，如果有括号，则...
实验十四 ARM 混合语言程序设计
最新发布
04-18
### 实验十四 ARM 混合语言程序设计 #### 实验背景及意义 在现代嵌入式系统开发中，ARM架构因其低功耗、高性能等特点而被广泛应用。ARM处理器支持两种编程模式：C语言和汇编语言。通常情况下，开发者会使用C语言...
混合高斯模型十四按前景提取，目标追踪
09-21
混合高斯模型十四按前景提取，目标追踪， 使用时候只需将你的视频名字进行更改，创建文件夹， 提取的前景图像会才在文件夹中；
一年级数学下册练习十四连加连减和加减混合运算2试题北京版202003172227
09-09
这篇资料主要针对一年级的学生，涉及的是数学基础知识，特别是连加、连减以及加减混合运算。这些运算在小学低年级的数学学习中是非常基础且重要的部分，它们是孩子们理解和掌握基本算术运算的关键步骤。 1. **连加*...
二十四节气小暑（PS素材资源 PSD源文件图片下载）.zip
04-30
【二十四节气小暑】是中国传统农历中的一个节气，标志着夏季的正式开始，一般在每年的7月7日或8日。这个时期，天气逐渐炎热，但尚未达到最热的"大暑"阶段。小暑的到来，意味着农民们开始忙碌于农作物的生长管理，而...
OpenGL Blend 和OpenGL中alpha测试GL_ALPHA_TEST
LC_若水微韧的博客
11-11 3899
OpenGL Blend 和OpenGL中alpha测试GL_ALPHA_TEST   像素的Alpha值可以用于混合操作 什么是混合呢？简单地说，就是当你透过一块红色的玻璃去看一个绿色的球时，此时就会发生颜色的混合现象，你看到的球的颜色将是两者的混合颜色。这在OpenGL里面有特殊的处理颜色混合的函数，比较常用GL_BLEND 要使用OpenGL的混合功能，调用：glEnable(GL
OpenGL第九章——混合
weixin_47524903的博客
01-14 2523
OpenGL颜色混合，透明
LearnOpenGL学习笔记——混合
VIPCCJ的博客
05-03 848
混合（个人感觉叫透明度更好些） OpenGL中，混合(Blending)通常是实现物体透明度(Transparency)的一种技术。明就是说一个物体（或者其中的一部分）不是纯色(Solid Color)的，它的颜色是物体本身的颜色和它背后其它物体的颜色的不同强度结合。一个有色玻璃窗是一个透明的物体，玻璃有它自己的颜色，但它最终的颜色还包含了玻璃之后所有物体的颜色。这也是混合这一名字的出处，我们混合(Blend)（不同物体的）多种颜色为一种颜色。所以透明度能让我们看穿物体。也就是我们通常说的RGBA，A指的a
OpenGL 入门 14：混合
On_The_Way
03-03 269
OpenGL 混合
安卓——按钮的四种点击事件
热门推荐
zw1996的博客
01-16 1万+
按钮Button，点击它则产生某个事件。 例如这个电话拨号器，那个拨号按钮就是这样的，当点击拨号按钮的时候就要进行打电话操作， 按照电话拨号器的小工程为例； 首先要找到按钮的，使用R中的id来查找； 设置按钮点击事件；使用setOnClickListener方法；其方法介绍； void android.view.View.setOnClickListener(OnClickList
用python写一个代码十个数字加减混合运算
04-20
当然可以，请看下面的Python代码示例： ```python import random def generate_expression(): # 随机生成 10 个数字 numbers = [random.randint(1, 100) for i in range(10)] # 随机生成 9 个运算符（包括加、减、乘、除） operators = [random.choice(['+', '-', '*', '/']) for i in range(9)] # 用运算符组成表达式 expr = '' for i in range(9): expr += str(numbers[i]) + operators[i] expr += str(numbers[9]) # 计算表达式的值 try: result = eval(expr) except ZeroDivisionError: # 如果出现除零错误，则重新生成一个表达式 return generate_expression() return {'expression': expr, 'result': result} if __name__ == '__main__': expression = generate_expression() print('表达式：', expression['expression']) print('结果：', expression['result']) ``` 该代码会随机生成 10 个数字，然后用加、减、乘、除四个运算符组成表达式，并计算表达式的值。如果表达式中出现除零错误，则重新生成一个表达式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值