精华内容
下载资源
问答
  • openGL大作业---机器人

    2013-12-26 19:11:59
    opengl大作业,机器人。
  • opengl大作业 在前两篇文章(第1条和第2条)中,我试图介绍android上的OpenGL ES。 现在,让我们更进一步,并在此基础上进一步发展。 在本文中,我们将创建一个广告牌(正方形),并在其上应用纹理。 纹理只不过是位图...
    opengl大作业

    opengl大作业

    在前两篇文章(第1条第2条)中,我试图介绍android上的OpenGL ES。 现在,让我们更进一步,并在此基础上进一步发展。 在本文中,我们将创建一个广告牌(正方形),并在其上应用纹理。 纹理只不过是位图图像。 在2D模式下工作时,我们将Z坐标设置为0。稍后我们将介绍3D模式。 这对于在2D游戏中使用非常有用,并且是使用OpenGL显示图像的首选方式。 确实非常快。

    在前面的文章中,我们设法显示了三角形。 那么如何显示正方形呢? 一个正方形由2个三角形组成。

    下图显示了这一点:

    三角形的正方形

    这里有一件有趣的事情要注意。 正方形是ABDC,而不是通常的ABCD 这是为什么? 因为OpenGL如何将三角形链接在一起。

    您在这里看到的是一个三角带 三角形带是一系列连接的三角形,在我们的例子中是2个三角形。

    OpenGL使用顶点按以下顺序绘制以下三角形带(即正方形):

    三角形1: V1-> V2-> V3

    三角形2: V3-> V2-> V4

    三角带

    它使用顶点按顺序绘制第一个三角形,然后从上一个三角形获取最后一个顶点,并使用该三角形的最后一面作为新三角形的基础。

    这也有好处:我们从内存中消除了冗余数据。

    抓住上一篇文章中的项目,并创建一个名为Square的新类。

    如果将Square类与Triangle类进行比较,您会发现只有一个区别:

    package net.obviam.opengl;
    
    import java.nio.ByteBuffer;
    import java.nio.ByteOrder;
    import java.nio.FloatBuffer;
    
    import javax.microedition.khronos.opengles.GL10;
    
    public class Square {
    
    	private FloatBuffer vertexBuffer;	// buffer holding the vertices
    
    	private float vertices[] = {
    			-1.0f, -1.0f,  0.0f,		// V1 - bottom left
    			-1.0f,  1.0f,  0.0f,		// V2 - top left
    			 1.0f, -1.0f,  0.0f,		// V3 - bottom right
    			 1.0f,  1.0f,  0.0f			// V4 - top right
    	};
    
    	public Square() {
    		// a float has 4 bytes so we allocate for each coordinate 4 bytes
    		ByteBuffer vertexByteBuffer = ByteBuffer.allocateDirect(vertices.length * 4);
    		vertexByteBuffer.order(ByteOrder.nativeOrder());
    
    		// allocates the memory from the byte buffer
    		vertexBuffer = vertexByteBuffer.asFloatBuffer();
    
    		// fill the vertexBuffer with the vertices
    		vertexBuffer.put(vertices);
    
    		// set the cursor position to the beginning of the buffer
    		vertexBuffer.position(0);
    	}
    
    	/** The draw method for the square with the GL context */
    	public void draw(GL10 gl) {
    		gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
    
    		// set the colour for the square
    		gl.glColor4f(0.0f, 1.0f, 0.0f, 0.5f);
    
    		// Point to our vertex buffer
    		gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);
    
    		// Draw the vertices as triangle strip
    		gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, vertices.length / 3);
    
    		//Disable the client state before leaving
    		gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
    	}
    }

    区别在于突出显示的行(13-18)。 没错,我们在顶点数组中又添加了一个顶点。

    现在更改GlRenderer,以便使用Square代替Triangle

    package net.obviam.opengl;
    
    import javax.microedition.khronos.egl.EGLConfig;
    import javax.microedition.khronos.opengles.GL10;
    
    import android.opengl.GLU;
    import android.opengl.GLSurfaceView.Renderer;
    
    public class GlRenderer implements Renderer {
    
    	private Square 		square;		// the square
    
    	/** Constructor to set the handed over context */
    	public GlRenderer() {
    		this.square		= new Square();
    	}
    
    	@Override
    	public void onDrawFrame(GL10 gl) {
    		// clear Screen and Depth Buffer
    		gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
    
    		// Reset the Modelview Matrix
    		gl.glLoadIdentity();
    
    		// Drawing
    		gl.glTranslatef(0.0f, 0.0f, -5.0f);		// move 5 units INTO the screen
    												// is the same as moving the camera 5 units away
    		square.draw(gl);						// Draw the triangle
    
    	}
    
    	@Override
    	public void onSurfaceChanged(GL10 gl, int width, int height) {
    		if(height == 0) { 						//Prevent A Divide By Zero By
    			height = 1; 						//Making Height Equal One
    		}
    
    		gl.glViewport(0, 0, width, height); 	//Reset The Current Viewport
    		gl.glMatrixMode(GL10.GL_PROJECTION); 	//Select The Projection Matrix
    		gl.glLoadIdentity(); 					//Reset The Projection Matrix
    
    		//Calculate The Aspect Ratio Of The Window
    		GLU.gluPerspective(gl, 45.0f, (float)width / (float)height, 0.1f, 100.0f);
    
    		gl.glMatrixMode(GL10.GL_MODELVIEW); 	//Select The Modelview Matrix
    		gl.glLoadIdentity(); 					//Reset The Modelview Matrix
    	}
    
    	@Override
    	public void onSurfaceCreated(GL10 gl, EGLConfig config) {
    	}
    }

    运行此命令将产生以下结果:

    三角带形成一个正方形

    对此进行检查, Square类中的draw()方法现在应该有意义。

    public void draw(GL10 gl) {
    		gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
    
    		// set the colour for the square
    		gl.glColor4f(0.0f, 1.0f, 0.0f, 0.5f);
    
    		// Point to our vertex buffer
    		gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);
    
    		// Draw the vertices as triangle strip
    		gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, vertices.length / 3);
    
    		//Disable the client state before leaving
    		gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
    	}

    首先,我们使OpenGL使用顶点数组进行渲染。 我们的顶点数组包含正方形的顶点。

    gl.glVertexPointer (第5行)告诉opengl渲染器从何处获取顶点以及顶点的类型。

    第一个参数告诉一个顶点使用多少个坐标。 我们使用3(x,y,z)。 第二个参数表明值是float类型。

    第三个参数是数组顶点之间的偏移量。 这就是所谓的冲突 我们有一个紧密排列的数组,所以它是0

    最后,最后一个参数告诉顶点在哪里。 当然是我们的缓冲区vertexBuffer

    第11行中的gl.glDrawArrays告诉OpenGL绘制图元。 什么样的原始语? 第一个参数中指定的一个: GL10.GL_TRIANGLE_STRIP 它从先前设置的顶点缓冲区中提取顶点,并且遵循前面描述的三角形条的规则。

    第二个参数指定数组中顶点的起始索引。

    第3个参数告诉OpenGL,要渲染的多边形要使用多少个顶点。 因为在上一条语句( gl.glVertexPointer )中我们指定了3个坐标定义一个顶点,所以我们将提供顶点数组的长度除以3。在数组中有9个元素定义了3个顶点。

    glDisableClientState(GL10.GL_VERTEX_ARRAY)禁用包含顶点的数组的渲染状态。

    glEnableClientStateglDisableClientState视为程序中的begin…end语句。 我们基本上在OpenGL渲染器中输入子例程。 输入例程后,我们将设置变量(顶点缓冲区,颜色等),并执行其他子例程(绘制顶点)。 完成后,我们退出子例程。 我们在渲染器中隔离工作。

    确保在此阶段运行应用程序,并了解发生了什么。

    创建纹理

    现在有趣的部分。 让我们加载图像并创建纹理。 纹理就是图像。

    要了解如何在Android应用中加载图片,请参阅本文

    我们要使用Square类,因为我们想将纹理应用于正方形。

    我们需要加载图像,告诉opengl渲染器我们要使用它作为纹理,最后我们将告诉渲染器在原始图元(正方形)上确切显示它的位置。

    就像将箔纸放在窗户或墙壁上一样。 我为您提供了包含窗口大小图像的贴膜,并告诉您用它覆盖窗口,因此贴膜的左上角将位于窗口的左上角。 就是这样,让我们​​开始工作。

    OpenGL使用顶点计算出放置内容的位置。 因此,我们需要为图像创建一个数组。 但是这次,这将是2D,因为位图就像一张纸,是一个平面。

    添加纹理的坐标数组。

    private FloatBuffer textureBuffer;	// buffer holding the texture coordinates
    	private float texture[] = {
    			// Mapping coordinates for the vertices
    			0.0f, 1.0f,		// top left		(V2)
    			0.0f, 0.0f,		// bottom left	(V1)
    			1.0f, 1.0f,		// top right	(V4)
    			1.0f, 0.0f		// bottom right	(V3)
    	};

    我们需要以类似于vertexBuffer的方式创建textureBuffer 这发生在构造函数中,我们将只重用byteBuffer 检查新的构造函数:

    public Square() {
    		ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * 4);
    		byteBuffer.order(ByteOrder.nativeOrder());
    		vertexBuffer = byteBuffer.asFloatBuffer();
    		vertexBuffer.put(vertices);
    		vertexBuffer.position(0);
    
    		byteBuffer = ByteBuffer.allocateDirect(texture.length * 4);
    		byteBuffer.order(ByteOrder.nativeOrder());
    		textureBuffer = byteBuffer.asFloatBuffer();
    		textureBuffer.put(texture);
    		textureBuffer.position(0);
    	}

    我们将向Square类添加一个重要的方法。 loadGLTexture方法。 启动时将从渲染器中调用它。 它发生在onSurfaceCreated方法中。 这将从磁盘加载图像并将其绑定到OpenGL存储库中的纹理。 基本上,它将为处理后的图像分配一个内部ID,并且OpenGL API将使用它在其他纹理中对其进行标识。

    /** The texture pointer */
    	private int[] textures = new int[1];
    
    	public void loadGLTexture(GL10 gl, Context context) {
    		// loading texture
    		Bitmap bitmap = BitmapFactory.decodeResource(context.getResources(),
    				R.drawable.android);
    
    		// generate one texture pointer
    		gl.glGenTextures(1, textures, 0);
    		// ...and bind it to our array
    		gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);
    
    		// create nearest filtered texture
    		gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_NEAREST);
    		gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
    
    		// Use Android GLUtils to specify a two-dimensional texture image from our bitmap
    		GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);
    
    		// Clean up
    		bitmap.recycle();
    	}

    我们需要一个纹理指针数组。 OpenGL将在此处存储我们将在应用程序中使用的纹理的名称。 因为我们只有一个图像,所以我们将创建一个大小为1的数组。

    06行加载了以前复制到/ res / drawable-mdpi目录中的android位图,因此ID已生成。

    有关此位图的说明。 鼓励正方形。 它对扩展很有帮助。 因此,请确保纹理的位图是正方形(6×6、12×12、128×128等)。 如果不是正方形,请确保宽度和高度为2的幂(2、4、8、16、32,…)。 您可以使用128×512的位图,它完全可用并且已优化。

    10行生成纹理的名称。 在我们的情况下,生成一个名称并将其存储在textures数组中。 即使显示名称,它实际上也会生成一个int值 有点令人困惑,但事实就是如此。

    12行将纹理与新生成的名称(texture [0])绑定。 这意味着,在此子例程中使用纹理的任何东西都将使用绑定的纹理。 它实际上激活了纹理。 绑定纹理是活动纹理。 如果我们有多个纹理和多个正方形可以使用它们,那么在使用它们之前,必须为每个正方形绑定(激活)适当的纹理。1516行设置了一些用于纹理的滤镜。 我们刚刚告诉OpenGL需要缩小或扩展纹理以覆盖正方形时使用什么类型的滤镜。 我们选择了一些有关如何缩放图像的基本算法。 现在不必为此担心。

    在第19行中,我们使用Android的实用程序为位图指定2D纹理图像。 它基于位图以内部格式在内部创建图像(纹理)。

    在第22行中,我们释放了内存。 您不应忘记这一点,因为设备上的内存非常有限并且图像很大。

    现在让我们看看如何修改draw()方法。

    public void draw(GL10 gl) {
    		// bind the previously generated texture
    		gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);
    
    		// Point to our buffers
    		gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
    		gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
    
    		// Set the face rotation
    		gl.glFrontFace(GL10.GL_CW);
    
    		// Point to our vertex buffer
    		gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);
    		gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, textureBuffer);
    
    		// Draw the vertices as triangle strip
    		gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, vertices.length / 3);
    
    		//Disable the client state before leaving
    		gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
    		gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
    	}
    }

    这不是上一篇文章的巨大修改。 这些增加已记录在案,并执行以下操作:

    03行使用存储在textures [0]中的名称(整数ID)绑定(激活)纹理。

    7行在当前OpenGL上下文中启用纹理映射。

    14行为OpenGL上下文提供了纹理坐标。用纹理绘制图元之后,我们将关闭纹理映射以及图元渲染。

    重要– UV贴图

    如果仔细查看,纹理映射坐标数组中的顶点顺序将不遵循正方形顶点坐标数组中的顺序。

    此处对纹理映射坐标有很好的解释: http : //iphonedevelopment.blogspot.com/2009/05/opengl-es-from-ground-up-part-6_25.html

    我将尽力快速解释它。 检查下图。

    正方形和纹理坐标排序

    正方形由2个三角形组成,并且顶点按以下顺序排列。

    1 –左下

    2 –右下

    3 –左上方

    4 –右上方

    注意逆时针路径。

    纹理坐标的顺序为:1-> 3-> 2-> 4

    如果您从另一个角开始绘制形状,请记住此映射并旋转它。 要阅读UV映射,请查看Wikipedia条目或在网上搜索。

    对于最后一部分,要使其工作,我们需要向渲染器提供上下文,以便在启动时加载纹理。

    onSurfaceCreated方法将如下所示。

    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
    		// Load the texture for the square
    		square.loadGLTexture(gl, this.context);
    
    		gl.glEnable(GL10.GL_TEXTURE_2D);			//Enable Texture Mapping ( NEW )
    		gl.glShadeModel(GL10.GL_SMOOTH); 			//Enable Smooth Shading
    		gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f); 	//Black Background
    		gl.glClearDepthf(1.0f); 					//Depth Buffer Setup
    		gl.glEnable(GL10.GL_DEPTH_TEST); 			//Enables Depth Testing
    		gl.glDepthFunc(GL10.GL_LEQUAL); 			//The Type Of Depth Testing To Do
    
    		//Really Nice Perspective Calculations
    		gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST);
    	}

    03行加载纹理。 其余各行仅使用一些值配置渲染器。 您现在不必担心它们。

    您将需要为Square对象提供应用程序上下文,因为对象本身会加载纹理,并且需要知道位图的路径。

    只需在Run活动的onCreate方法( glSurfaceView.setRenderer(new GlRenderer(this)); )中为渲染器提供上下文即可。

    确保渲染器具有通过构造函数声明和设置的上下文。

    GlRendered类的节选。

    private Square 		square;		// the square
    	private Context 	context;
    
    	/** Constructor to set the handed over context */
    	public GlRenderer(Context context) {
    		this.context = context;
    
    		// initialise the square
    		this.square = new Square();
    	}

    如果运行代码,您应该会看到一个正方形,上面放着一个漂亮的机器人。

    带有Android纹理的正方形

    此处下载源代码和项目(obviam.opengl.p03.tgz)。

    参考: 纹理贴图–来自“反对谷物”博客的JCG合作伙伴Tamas Jano的OpenGL Android(使用OpenGL和Squares显示图像)

    不要忘记查看我们的新Android游戏ArkDroid (以下屏幕截图) 您的反馈将大有帮助!
    相关文章:

    翻译自: https://www.javacodegeeks.com/2011/10/android-game-development-opengl-texture.html

    opengl大作业

    展开全文
  • 杭州电子科技大学《实时三维图形绘制》OpenGL大作业实验报告
  • opengl大作业 乡间小屋

    热门讨论 2011-12-12 21:42:35
    f为雾化控制,鼠标右键打开菜单,方向键调整视角。 本程序应用了渲染,回显列表,粒子系统,纹理贴图,定时回调,光照,消隐,伪装反射等技术 本程序可继续加入投影,视点切换,移动,鼠标响应,中文字幕,凹凸...
  • OPenGL大作业实现旋转

    2010-05-20 22:58:15
    OPENGL实现一个复杂的机器人模型,在其中有详细的代码描述
  • 计算机图形学大作业,实现了真实场景模拟,有配乐,可控。
  • 大一刚上完程序设计基础课的大作业,要求用到图形库,懵逼的我 临时参考网上的程序初步了解了一下。 https://blog.csdn.net/GUOXIAOHE0000/article/details/80893549 在上链接的代码中进行了修改,删去了一些东西。...
  • #include "stdafx.h" #include<stdio.h> #define GLUT_DISABLE_ATEXIT_HACK //不写这句话总运行出错,我也不知道为啥。。。 #include<gl/GLUT.h> #include<...static GLfloat spin ...
    #include "stdafx.h"
    #include<stdio.h>
    #define GLUT_DISABLE_ATEXIT_HACK //不写这句话总运行出错,我也不知道为啥。。。
    #include<gl/GLUT.h>
    #include<math.h>
    int change = 10;
    static GLfloat spin = 0.0;//static:静态全局变量,只要程序运行,内存中一直存在,文件内可见,文件外不可见
    
    void init(void)
    {
        glClearColor(0.0, 0.0, 0.0, 0.0);//将清空颜色设置为黑
        
    }
    int z = -1;
    void fillOption(GLint selectedOption)
    {
         z = -1;
        switch (selectedOption) {
        case 1:change-=2;   break; 
        case 2:z=-z;  break; 
        case 3:z =0;  break;
        }
        glutPostRedisplay();
    }
    void display(void)
    {
        glClear(GL_COLOR_BUFFER_BIT);//清除颜色缓存
        glPushMatrix();//将当前矩阵压栈(保存现场)
        glRotatef(spin, 0.0, 0.0,z);//旋转方向,遵循右手原则
        glColor3f(1.0, 1.0, 1.0);
        glEnable(GL_LINE_SMOOTH);//让线条更平滑
        GLint x = 100;
        GLdouble a = 1.256637, c = 1;
        while (x--)
        {
            glShadeModel(GL_SMOOTH);//渐变色
            glBegin(GL_LINE_STRIP);
            
            glVertex2f(50 * cos(a + c), 50 * sin(a + c));
            glColor3f(1.0, 0.0, 0.0);
            glVertex2f(50 * cos(3 * a + c), 50 * sin(3 * a + c));
            glColor3f(0.0, 1.0, 0.0);
            glVertex2f(50 * cos(5 * a + c), 50 * sin(5 * a + c));
            glColor3f(0.0, 0.0, 1.0);
            glVertex2f(50 * cos(2 * a + c), 50 * sin(2 * a + c));
            glColor3f(0.0, 1.0, 1.0);
            glVertex2f(50 * cos(4 * a + c), 50 * sin(4 * a + c));
            glColor3f(1.0, 1.0, 1.0);
            glVertex2f(50 * cos(a + c), 50 * sin(a + c));
            glEnd();
            c+=0.0314159365*change;
            
        }
        glColor3f(1.0, 0.0, 0.0);
        glBegin(GL_LINE_STRIP);
        
        glEnd();
        glPopMatrix();
        glutSwapBuffers();//双缓存技术的函数,作用为交换两个缓冲区的指针
    }
    void spinDisplay(void)
    {
        spin = spin + 0.04;
        if (spin > 360.0)
        {
            spin = spin - 360.0;
        }
        glutPostRedisplay();//glutPostRedisplay 标记当前窗口需要重新绘制。通过glutMainLoop下一次循环时,窗口显示将被回调以重新显示窗口的正常面板
    }
    void reshape(int w, int h)
    {
        glViewport(0, 0, (GLsizei)w, (GLsizei)h);//函数作用:用一个视景体截取图像
        glMatrixMode(GL_PROJECTION);//mode 指定哪一个矩阵堆栈是下一个矩阵操作的目标,参数表示接下来要进行投影相关的操作
        glLoadIdentity();//设置当前变化矩阵为单位矩阵;单位矩阵就是对角线上都是1,其余元素皆为0的矩阵。然后复位
        glOrtho(-50.0, 50.0, -50.0, 50.0, -1.0, 1.0);
        glMatrixMode(GL_MODELVIEW);//进行视景相关的操作
        glLoadIdentity();
    }
    void mouse(int button, int state, int x, int y)
    {
        switch (button)
        {
        case GLUT_LEFT_BUTTON:
            if (state == GLUT_DOWN)
                glutIdleFunc(spinDisplay);//glutIdleFunc函数如果启用,这个idle function会被不断调用,直到有窗口事件发生
            break;
        case GLUT_RIGHT_BUTTON:
            if (state == GLUT_DOWN)
                glutIdleFunc(NULL);
            break;
        default:
            break;
        }
    }
    
    int main(int argc, char** argv)
    {
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
        glutInitWindowSize(680, 680);
        glutInitWindowPosition(400, 0);
        glutCreateWindow("big homework");
        init();
        glutDisplayFunc(display);//每次重绘场景时调用
        glutCreateMenu(fillOption);  
        glutAddMenuEntry("amount", 1);
        glutAddMenuEntry("reverse", 2);
        glutAddMenuEntry("narrow", 3);
        glutAttachMenu(GLUT_RIGHT_BUTTON);
        glutReshapeFunc(reshape);//每次窗口改变时调用
        glutMouseFunc(mouse);//每次使用鼠标时调用
        glutMainLoop();
        return 0;
    }

     

    转载于:https://www.cnblogs.com/pqhuang/p/11270197.html

    展开全文
  • 本学期的OpenGL大作业做了一个3D二维码生成器: 可以动态更新纹理: 在数据的准备阶段,需要提取二维码关键点的信息,写了一个python脚本用来生成对应的二维数组: import qrcode import numpy as np ...

    本学期的OpenGL大作业做了一个3D二维码生成器:

    可以切换相机视角&更多功能等你添加。

    可以动态更新纹理: 

    在数据的准备阶段,需要提取二维码关键点的信息,写了一个python脚本用来生成对应的二维数组:

    import qrcode
    import numpy as np
    
    data = "http://idiospace.com"
    qr = qrcode.QRCode(
        version=1,			#version二维码的格子矩阵大小,可以是1到40
        error_correction=qrcode.constants.ERROR_CORRECT_L,	#error_correction二维码错误容许率,默认ERROR_CORRECT_M,容许小于15%的错误率
        box_size=1,	#box_size二维码每个小格子包含的像素数量
        border=0,	#border二维码到图片边框的小格子数,默认值为4
    )
    
    qr.add_data(data=data)
    img = qr.make_image(fill_color="black", back_color="white")
    img.show()  # 以BMP的格式输出图片
    
    img_arr = np.array(img)
    
    print(img_arr.shape)
    [rows, cols] = img_arr.shape
    for i in range(rows):
        for j in range(cols):
            if img_arr[j, i]:
                print("1", end="")
            else:
                print("0", end="")
            print(", ", end="")
        print("")
    
    
    

    可以生成得到二维数组:

    0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 
    0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 
    0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 
    0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 
    0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 
    0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 
    0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 
    1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
    0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 
    1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 
    1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 
    1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 
    1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 
    0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 
    0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 
    0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 
    0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 
    0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 
    0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 
    0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 
    0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 
    0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0

    输出得到需要硬编码到C++ OpenGL程序中去(这里可以改进!),然后点击Generate就可以生成:(Raw Message)

    就写了一周,时间有限,Demo粗糙,如果对你有帮助,可以点赞 / 评论 / Star,或者素质三连。 

     

    开源地址:Github

    展开全文
  • 实现机器人带光照的绘制和运动变换。通过glPushMatrix() 和glPopMatrix()绘制出机器人层次结构模型和几何变换,要求实现机器人手、脚、头、肩膀的旋转等几何变换,能够实现机器人走路的效果。同时机器人打上光照。...
  • OpenGL粒子系统大作业,实现了真实场景模拟,有配乐,可控。
  • OpenGL的3D场景模型大作业

    万次阅读 多人点赞 2019-01-15 17:17:09
    本文标题:OpenGL的3D场景模型大作业 本文链接:https://blog.xygeng.cn/182.html 作者授权:除特别说明外,本文由庚哥哥原创编译并授权木芽博客刊载发布。 版权声明:本文不使用任何协议授权,您可以任何形式...

    【题目】


    opengl 3D环境开发

     

    本文标题:OpenGL的3D场景模型大作业

    本文链接:https://xygeng.cn/post/84.html

    作者授权:除特别说明外,本文由 庚哥哥 原创编译并授权 木芽博客 刊载发布。

    版权声明:本文不使用任何协议授权,您可以任何形式自由转载或使用。

     

    【内容】


     

    绘制一个简单的三维场景,可以是室内:卧室,办公室,教室,也可以是室外:运动场,公园等,加上光照效果,透视投影,不能过于简单

    可以加动画,加上鼠标和键盘交互

     

    1. 一、题目:


     

    Opengl大作业

     

    1. 二、程序分析:


     

    1、实现三维场景,可以游览以及可以看到模型物体的不同状态。

    2、三维场景有不同的模型组合,有房子,有地球,有月球。

    3、可以看到物体的自由移动,汽车在公路上自由移动。

    4、可以模拟真实的光照效果,具有阴影体现,可以呈现地球的白天黑夜。

    5、模拟粒子系统的,下雪效果。

    7、物体旋转,地球自转和月球绕着地球转

    8、房子有真实效果的模型和细节。

     

    1. 三、程序树形建模


    image.png

     

     

    1. 四、程序函数解析


    image.png

     

    1. 五、程序结构分层


     

    image.png

     

     

    1. 六、程序代码详细


      代码太长略,需求者找博主。

     

     

    1. 七、程序运行结果


       

     

    1.       地月系

     

    image.png

     

    1.       汽车移动:

     

    image.png

     

    1.       大厅

     

    image.png

     

    image.png

     

    1.       餐桌

     

    image.png

     

    1.       电视墙:

     

    image.png

     

    image.png

     

    1.       沙发:

     

    image.png

     

    1.       水族箱

     

    image.png

     

    1.       卫生间:

     

    image.png

     

    1.       房间:

     

    image.png

     

    image.png

     

    1.       雪花:

     

    image.png

     

    1.  八、课程心得体会


      本次大作业运用了光照,粒子系统,模型等综合项目,模型中运用了大量的纹理贴图来充实这个场景的细节,在模型运动和视角转换的过程中运用了矩阵的转换来实现,具体了解了世界视角和视觉视角的矩阵转换,投影模型过程,对纹理和光照各个属性的设置来呈现不同的效果。此程序是基于地月系,然后房子各个细节的呈现,是综合性的小程序。通过本次大作业,能更好的运用opengl的函数绘制场景,更能了解到图形在计算机的程序的原理与运用,宏观的接触了图形学的领域。

    本文标题:OpenGL的3D场景模型大作业

    本文链接:https://xygeng.cn/post/84.html

    作者授权:除特别说明外,本文由 庚哥哥 原创编译并授权 木芽博客 刊载发布。

    版权声明:本文不使用任何协议授权,您可以任何形式自由转载或使用。

     

    展开全文
  • ​ For 可以自己实现OpenGL编写的朋友 导入模型 :给出的数据为顶点坐标,没有法线信息,需要求解法线,在我的实现中对每一三角面根据三点坐标求解了法线,没有进行法线插值,这会使得兔兔表面不够圆润,并且需要 ...
  • 自己为图形学课程写的大作业,是在vc6.0的环境下用OPENGL实现一个简易的保龄球小程序。
  • 内包括实验报告,源程序,截图文件,txt文件

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 218
精华内容 87
关键字:

opengl大作业