3D立方体及光照

最新推荐文章于 2024-09-02 07:32:54 发布
原创 最新推荐文章于 2024-09-02 07:32:54 发布 · 1.9k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#textures #float #buffer #timer #components #filter

 本代码主要实现了一个旋转立方体， 并添加了光照效果。

 

Qt 版：

myglwidget.h

#ifndef MYGLWIDGET_H
#define MYGLWIDGET_H

#include <QGLWidget>
#include <QVector2D>
#include <QVector3D>
#include <QTimer>

class MyGLWidget : public QGLWidget
{
    Q_OBJECT
public:
    explicit MyGLWidget(QWidget *parent = 0);

signals:

public slots:

protected:
    // Set up the rendering context, define display lists etc.:
    void initializeGL();

    void resizeGL(int w, int h);

    void paintGL();

private:
    void makeObject();
    void initLighting();

    GLfloat		xrot;								// X 旋转量
    GLfloat		yrot;								// Y 旋转量
    GLfloat		zrot;								// Z 旋转量

    GLuint		textures[6];							// 存储一个纹理

    QVector<QVector3D> vertices;
    QVector<QVector2D> texCoords;

    QTimer *timer;
};


#endif // MYGLWIDGET_H


myglwidget.cpp

#include "myglwidget.h"

#ifndef GL_MULTISAMPLE
#define GL_MULTISAMPLE  0x809D
#endif

MyGLWidget::MyGLWidget(QWidget *parent) :
    QGLWidget(parent)
{
    xrot = 0.0f;
    yrot = 0.0f;
    zrot = 0.0f;

    timer = new QTimer(this);
    connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
    timer->start(10);
}

 void MyGLWidget::initializeGL()
 {
     makeObject();initLighting();
     glShadeModel(GL_SMOOTH);						// 启用阴影平滑
     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);				// 黑色背景
     glClearDepth(1.0f);						// 设置深度缓存
     glEnable(GL_CULL_FACE);
     glEnable(GL_TEXTURE_2D);
     glEnable(GL_DEPTH_TEST);						// 启用深度测试
     glDepthFunc(GL_LEQUAL);						// 所作深度测试的类型
     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);			// 告诉系统对透视进行修正

 }

 void MyGLWidget::resizeGL(int width, int height)
 {
     if (height==0)							// 防止被零除
     {
             height=1;							// 将Height设为1
     }

     glViewport(0, 0, width, height);					// 重置当前的视口
     glMatrixMode(GL_PROJECTION);					// 选择投影矩阵
     glLoadIdentity();                                                  // 重置投影矩阵

     // 设置视口的大小
     gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

     glMatrixMode(GL_MODELVIEW);					// 选择模型观察矩阵
     glLoadIdentity();							// 重置模型观察矩阵

 }

 void MyGLWidget::paintGL()
 {
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);			// 清除屏幕和深度缓存
     glLoadIdentity();							// 重置当前的模型观察矩阵
     glColor3f(1.0, 0.0, 1.0);

     glTranslatef(0.0f,0.0f,-5.0f);						// 移入屏幕 5 个单位

     glRotatef(xrot,1.0f,0.0f,0.0f);						// 绕X轴旋转
     glRotatef(yrot,0.0f,1.0f,0.0f);						// 绕Y轴旋转
     glRotatef(zrot,0.0f,0.0f,1.0f);						// 绕Z轴旋转

     glVertexPointer(3, GL_FLOAT, 0, vertices.constData());
     glTexCoordPointer(2, GL_FLOAT, 0, texCoords.constData());
     glEnableClientState(GL_VERTEX_ARRAY);
     glEnableClientState(GL_TEXTURE_COORD_ARRAY);

     for (int i = 0; i < 6; ++i) {
         glBindTexture(GL_TEXTURE_2D, textures[i]);
         glDrawArrays(GL_TRIANGLE_FAN, i * 4, 4);
     }

     xrot+=0.3f;								// X 轴旋转
     yrot+=0.2f;								// Y 轴旋转
     zrot+=0.4f;								// Z 轴旋转

 }

 void MyGLWidget::initLighting()
 {
     GLfloat lightPos[] = { 75.0f, 0.0f, 0.0f, 1.0f };
     GLfloat specular[] = { 1.0f, 1.0f, 1.0f, 1.0f};
     GLfloat specref[] = { 1.0f, 1.0f, 1.0f, 1.0f };
     GLfloat ambientLight[] = { 0.5f, 0.5f, 0.5f, 1.0f};
     GLfloat spotDir[] = { 0.0f, 0.0f, -1.0f };

     glEnable(GL_DEPTH_TEST); // Hidden surface removal
     glFrontFace(GL_CCW); // Counterclockwise polygons face out
     glEnable(GL_CULL_FACE); // Do not try to display the back sides

     // Enable lighting
     glEnable(GL_LIGHTING);
     // Set up and enable light 0
     // Supply a slight ambient light so the objects can be seen
     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientLight);

     // The light is composed of just diffuse and specular components
     glLightfv(GL_LIGHT0,GL_DIFFUSE,ambientLight);
     glLightfv(GL_LIGHT0,GL_SPECULAR,specular);
     glLightfv(GL_LIGHT0,GL_POSITION,lightPos);

     // Specific spot effects
     // Cut-off angle is 60 degrees
     glLightf(GL_LIGHT0,GL_SPOT_CUTOFF,60.0f);

     // Enable this light in particular
     glEnable(GL_LIGHT0);
     // Enable color tracking
     glEnable(GL_COLOR_MATERIAL);
     // Set material properties to follow glColor values
     glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
     // All materials hereafter have full specular reflectivity
     // with a high shine
     glMaterialfv(GL_FRONT, GL_SPECULAR,specref);
     glMateriali(GL_FRONT, GL_SHININESS,128);
     // Black background
     glClearColor(0.0f, 0.0f, 0.0f, 1.0f );
 }

 void MyGLWidget::makeObject()
 {
     static const int coords[6][4][3] = {
         { { +1, -1, -1 }, { -1, -1, -1 }, { -1, +1, -1 }, { +1, +1, -1 } },
         { { +1, +1, -1 }, { -1, +1, -1 }, { -1, +1, +1 }, { +1, +1, +1 } },
         { { +1, -1, +1 }, { +1, -1, -1 }, { +1, +1, -1 }, { +1, +1, +1 } },
         { { -1, -1, -1 }, { -1, -1, +1 }, { -1, +1, +1 }, { -1, +1, -1 } },
         { { +1, -1, +1 }, { -1, -1, +1 }, { -1, -1, -1 }, { +1, -1, -1 } },
         { { -1, -1, +1 }, { +1, -1, +1 }, { +1, +1, +1 }, { -1, +1, +1 } }
     };

     for (int j=0; j < 6; ++j) {
         textures[j] = bindTexture
             (QPixmap(QString(":/images/side%1.png").arg(j + 1)), GL_TEXTURE_2D);
     }

     for (int i = 0; i < 6; ++i) {
         for (int j = 0; j < 4; ++j) {
             texCoords.append
                 (QVector2D(j == 0 || j == 3, j == 0 || j == 1));
             vertices.append
                 (QVector3D(0.5 * coords[i][j][0], 0.5 * coords[i][j][1],
                            0.5 * coords[i][j][2]));
         }
     }
 }


main.cpp

#include <QApplication>
#include "myglwidget.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MyGLWidget win ;
    win.show();

    return a.exec();
}


Android 版本：

MyRender.java

import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.opengl.GLSurfaceView.Renderer;
import android.opengl.GLU;
import android.opengl.GLUtils;

public class MyRenderer implements Renderer {

	public MyRenderer(Context ctx) {
		mContext = ctx;
	}
	
	@Override
	public void onDrawFrame(GL10 gl) {
		// TODO Auto-generated method stub
	     gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);			// 清除屏幕和深度缓存
	     gl.glMatrixMode(GL10.GL_MODELVIEW);
	     gl.glLoadIdentity();							// 重置当前的模型观察矩阵

	     
	     gl.glTranslatef(0, 0, 5);

	     gl.glRotatef(xrot,1.0f,0.0f,0.0f);						// 绕X轴旋转
	     gl.glRotatef(yrot,0.0f,1.0f,0.0f);						// 绕Y轴旋转
	     gl.glRotatef(zrot,0.0f,0.0f,1.0f);						// 绕Z轴旋转

	     gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
	     gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
	     gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);
	     gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, mTexBuffer);

	     for (int i = 0; i < 6; ++i) {
	         gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[i]);
	         gl.glDrawArrays(GL10.GL_TRIANGLE_FAN, i * 4, 4);
	     }

	     xrot+=0.3f;								// X 轴旋转
	     yrot+=0.2f;								// Y 轴旋转
	     zrot+=0.4f;								// Z 轴旋转
	}

	@Override
	public void onSurfaceChanged(GL10 gl, int width, int height) {
		// TODO Auto-generated method stub
	     if (height==0)							// 防止被零除
	     {
	             height=1;							// 将Height设为1
	     }

	     gl.glViewport(0, 0, width, height);					// 重置当前的视口
	     gl.glMatrixMode(GL10.GL_PROJECTION);					// 选择投影矩阵
	     gl.glLoadIdentity();                                                  // 重置投影矩阵

	     // 设置视口的大小
	     GLU.gluPerspective(gl, 45.0f,(float)width/(float)height,0.1f,100.0f);
	     
	     GLU.gluLookAt(gl, 0, 0, -5, 0, 0, 0, 0, 1, 0);

	     gl.glMatrixMode(GL10.GL_MODELVIEW);			// 选择模型观察矩阵
	     gl.glLoadIdentity();							// 重置模型观察矩阵
	}

	@Override
	public void onSurfaceCreated(GL10 gl, EGLConfig config) {
		// TODO Auto-generated method stub
		makeObject(gl);
		initLigthing(gl);
	
	    gl.glEnable(GL10.GL_DEPTH_TEST);
	    gl.glEnable(GL10.GL_CULL_FACE);
	    gl.glFrontFace(GL10.GL_CW);
	    gl.glEnable(GL10.GL_TEXTURE_2D);
//		gl.glEnable(GL10.GL_LIGHTING);
//		gl.glEnable(GL10.GL_LIGHT0);
	}
	
	private int bindTexture(GL10 gl, int rsid) {
		int[] textures = new int[1];
		// 创建纹理
		gl.glGenTextures(1, textures, 0);
		gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);
		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);
		gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S,
				GL10.GL_CLAMP_TO_EDGE);
		gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T,
				GL10.GL_CLAMP_TO_EDGE);
		gl.glTexEnvf(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE,
				GL10.GL_REPLACE);

		InputStream is = mContext.getResources().openRawResource(rsid);
		Bitmap bitmapTmp;

		try {
			bitmapTmp = BitmapFactory.decodeStream(is);
		} finally {
			try {
				is.close();
			} catch (IOException e) {
				// Ignore.
			}
		}

		GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmapTmp, 0);
		bitmapTmp.recycle();
		
		return textures[0];
	}
	
	private void initLigthing(GL10 gl) {
		float mat_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
		float mat_shininess[] = { 50.0f };
		float light_position[] = { 0.0f, 0.0f, 1.0f, 0.0f };
		float white_light[] = { 1.0f, 1.0f, 1.0f, 1.0f };
		float lmodel_ambient[] = { 0.1f, 0.1f, 0.1f, 1.0f };
		
//		gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
//		gl.glShadeModel(GL10.GL_SMOOTH);
		
		FloatBuffer specularBuffer;
		ByteBuffer  bb1 = ByteBuffer.allocateDirect(mat_specular.length * 4);
		bb1.order(ByteOrder.nativeOrder());
		specularBuffer = bb1.asFloatBuffer();		
		gl.glMaterialfv(GL10.GL_FRONT, GL10.GL_SPECULAR, specularBuffer);
		
		FloatBuffer shininessBuffer;
		ByteBuffer bb2 = ByteBuffer.allocateDirect(mat_shininess.length * 4);
		bb2.order(ByteOrder.nativeOrder());
		shininessBuffer = bb2.asFloatBuffer();		
		gl.glMaterialfv(GL10.GL_FRONT, GL10.GL_SHININESS, shininessBuffer);
		
		FloatBuffer positionBuffer;
		ByteBuffer bb3 = ByteBuffer.allocateDirect(light_position.length * 4);
		bb3.order(ByteOrder.nativeOrder());
		positionBuffer = bb3.asFloatBuffer();		
		gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_POSITION, positionBuffer);
		
		FloatBuffer lightBuffer;
		ByteBuffer bb4 = ByteBuffer.allocateDirect(white_light.length * 4);
		bb4.order(ByteOrder.nativeOrder());
		lightBuffer = bb4.asFloatBuffer();		
		gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_DIFFUSE, lightBuffer);		
		gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_SPECULAR, lightBuffer);
		
		FloatBuffer ambientBuffer;
		ByteBuffer bb5 = ByteBuffer.allocateDirect(lmodel_ambient.length * 4);
		bb5.order(ByteOrder.nativeOrder());
		ambientBuffer = bb5.asFloatBuffer();		
		gl.glLightModelfv(GL10.GL_LIGHT_MODEL_AMBIENT, ambientBuffer);
		
	     gl.glEnable(GL10.GL_LIGHTING);
	     gl.glEnable(GL10.GL_LIGHT0);

	}
	
	private void makeObject(GL10 gl) {
		float []vertices = {
				//底部
				 +1, -1, -1 , 
				 -1, -1, -1 , 
				 -1, +1, -1 , 
				 +1, +1, -1 ,
				 //后面
				 +1, +1, -1 , 
				 -1, +1, -1 , 
				 -1, +1, +1 , 
				 +1, +1, +1 , 
				//右面
				 +1, -1, +1 , 
				 +1, -1, -1 , 
				 +1, +1, -1 , 
				 +1, +1, +1 ,
				 //左面
				 -1, -1, -1 , 
				 -1, -1, +1 , 
				 -1, +1, +1 , 
				 -1, +1, -1 ,
				 //前面
				 +1, -1, +1 , 
				 -1, -1, +1 , 
				 -1, -1, -1 , 
				 +1, -1, -1 ,
				 //顶面
				 -1, -1, +1 , 
				 +1, -1, +1 , 
				 +1, +1, +1 , 
				 -1, +1, +1  
	     };
		
		for (int i = 0; i < vertices.length; i++)
			vertices[i] = (float) (0.5 * vertices[i]);
		
		float []texcoords = {
				// 前面
				0.0f, 0.0f, // 纹理左下
				1.0f, 0.0f,	// 纹理右下
				1.0f, 1.0f,	// 纹理右上
				0.0f, 1.0f,	// 纹理左上
				// 后面
				1.0f, 0.0f,	// 纹理右下
				1.0f, 1.0f,	// 纹理右上
				0.0f, 1.0f,	// 纹理左上
				0.0f, 0.0f,	// 纹理左下
				// 顶面
				0.0f, 1.0f,	// 纹理左上
				0.0f, 0.0f,	// 纹理左下
				1.0f, 0.0f,	// 纹理右下
				1.0f, 1.0f,	// 纹理右上
				// 底面
				1.0f, 1.0f,	// 纹理右上
				0.0f, 1.0f,	// 纹理左上
				0.0f, 0.0f,	// 纹理左下
				1.0f, 0.0f,	// 纹理右下		
				// 右面
				1.0f, 0.0f,	// 纹理右下
				1.0f, 1.0f,	// 纹理右上
				0.0f, 1.0f,	// 纹理左上
				0.0f, 0.0f,	// 纹理左下
				// 左面
				0.0f, 0.0f,	// 纹理左下
				1.0f, 0.0f,	// 纹理右下
				1.0f, 1.0f,	// 纹理右上
				0.0f, 1.0f	// 纹理左上		
		};
		
		int[] rids = { R.raw.side1, R.raw.side2, R.raw.side3, R.raw.side4, R.raw.side5, R.raw.side6 };

		textures = new int[6];
	     for (int j=0; j < 6; ++j) {
	         textures[j] = bindTexture(gl, rids[j]);
	     }
	     
	     ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4);
	     vbb.order(ByteOrder.nativeOrder());
	     vertexBuffer = vbb.asFloatBuffer();
	     vertexBuffer.put(vertices);
	     vertexBuffer.position(0);
	     
	     ByteBuffer tbb = ByteBuffer.allocateDirect(texcoords.length * 4);
	     tbb.order(ByteOrder.nativeOrder());
	     mTexBuffer = tbb.asFloatBuffer();
	     mTexBuffer.put(texcoords);
	     mTexBuffer.position(0);
	}
	
	private int textures[];
	
	private FloatBuffer vertexBuffer;
	
	private FloatBuffer mTexBuffer;
	
	private Context mContext;
	
	private static final float PI = 3.1415f;
    private float xrot = 0;							 
    private float yrot = 0;								 
    private float zrot = 0;

}


Activity

import android.app.Activity;
import android.opengl.GLSurfaceView;
import android.os.Bundle;

public class TextureTestActivity extends Activity {
    
	private GLSurfaceView mView;
	
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mView = new GLSurfaceView(this);
        mView.setRenderer(new MyRenderer(this));
        setContentView(mView);
    }
    
	@Override
	protected void onResume() {
		super.onResume();
		mView.onResume();
	}

	@Override
	protected void onPause() {
		super.onPause();
		mView.onPause();
	}
    
}


 

制作立方体光照纹理模型
m0_58837398的博客
01-05 924
1. 建立立方体类。2. 背面剔除算法消隐。3.PhongShader光照。4.使用六张纹理图片。
教你用python中的pygame做用鼠标旋转的正方体（含源码）
2401_86187906的博客
07-11 531
总之，整个程序的核心是通过数学运算实现正方体的旋转和投影，并使用 pygame 的绘图功能将其展示在屏幕上，同时根据鼠标操作实现交互。对于外部轮廓的绘制，通过明确正方体 12 条边的顶点顺序，将投影后的顶点连接成线来绘制轮廓，线条颜色为红色，宽度为 2。除了鼠标控制，添加键盘控制选项，例如特定的按键可以加速或减速旋转，或者改变旋转轴。引入简单的光照模型，使正方体在旋转时表面的明暗效果发生变化，增强立体感和真实感。增加多个可旋转的正方体，它们之间可以相互碰撞或产生某种关联的运动。绘制正方体的面为白色。
一个用opengl实现的带有光照和材质效果的立方体
04-29
用opengl实现的一个带有光照效果和材质效果的立方体模型
opengl光照立方体
12-16
opengl实心立方体，添加光照处理，可旋转
java 纹理_Java3D中的光和纹理
weixin_33279929的博客
02-16 306
我的问题是这个区别：还有这个：我正在尝试使用Java3D创建一个漂亮的太阳系,但是当我应用纹理时,光照效果消失,3D效果(当不是从上到下看行星时)也随之而来.如何在纹理表面上进行这种着色？我用于地球示例的代码如下所示.纹理可下载here.import com.sun.j3d.utils.geometry.Primitive;import com.sun.j3d.utils.geometry.Sph...
java3d效果_[转载]JAVA3D 灯光效果实例
weixin_30160343的博客
02-24 303
package unit5;import java.applet.Applet;import java.awt.BorderLayout;import java.awt.GraphicsConfiguration;import com.sun.j3d.utils.applet.MainFrame;import com.sun.j3d.utils.geometry.Sphere;import com...
python3 pygame load图片不显示_Python——mac下pygame踩坑，绘制图像不加载
weixin_31874577的博客
12-23 686
问题描述：mac下python3版本安装pygame后开发小游戏时，背景和角色在画布上不加载，创建游戏循环执行时，一直加载背景不刷新；pygame相对比较简单，直接上代码：import pygame# 游戏的初始化pygame.init()# 创建游戏的窗口 480 * 700screen = pygame.display.set_mode((480, 700))# 绘制背景图像bg = pyga...
精选资源
Python 3D立方体 支持拖拽旋转
最新发布
12-11
在探索三维图形编程的世界中，使用Python实现一个交互式的3D立方体，并赋予其拖拽和旋转功能，是一项既有趣又具有挑战性的任务。这样的项目不仅需要对Python编程语言有深入的理解，还需要掌握三维图形学的基础知识...
direct3d立方体多个贴图及旋转
03-19
Direct3D立方体的多个贴图与旋转是一个重要的三维图形编程概念，主要应用于游戏开发、图形用户界面（GUI）设计以及各种视觉效果的创建。在Direct3D中，立方体贴图通常用于环境映射，而旋转则涉及到物体的动态表现。...
mycube.rar_光照_立方体_立方体 旋转_立方体平移
09-23
总结来说，这个程序通过光照效果展示了立体的立方体，并允许用户对其进行旋转和平移，从而实现动态的3D视图。这种技术广泛应用于游戏开发、虚拟现实、建筑设计等多个领域，是理解计算机图形学基础的重要实践。
精选资源
3D立方体旋转相册特效
03-05
"3D立方体旋转相册特效"是一种利用现代网页技术实现的交互式视觉效果，它为用户提供了新颖的浏览照片的方式。在这个项目中，设计师利用HTML5的Canvas元素，配合JavaScript编程来创建一个3D环境，使用户可以通过鼠标...
3D立方体旋转展示动画特效源码.rar
01-27
在IT领域，3D立方体旋转展示动画特效是一种常见的视觉表现手法，广泛应用于网页设计、游戏开发、软件界面以及各种多媒体应用中。这种特效能够吸引用户的注意力，为用户带来更丰富的交互体验。以下是对"3D立方体旋转...
java3D显示一个球的代码
10-18
java3D入门的示例，显示一个球体，适合初学Java3D的人。
2D_Raycast_Simulation:pygame进行的简单光线模拟
03-08
2D Raycast模拟 使用pygame进行的简单光线模拟。 我用pygame制作的第一个程序，用于对该库进行实验。 外观：
UE4室内光照技法
02-10
此教程总结归纳了作者使用UE4对室内场景的灯光布置方法、流程等。许多在学习UE4的同仁们会纠结于各种大师做出的作品效果，殊不知其实最棒的例子就在我们身边，只要用心观察身边事物，加上灵活运用UE4给出的解决方案，就可以去模拟现实生活当中的真实光照。此教程会结合身边的案例，让大家去理解构成真实场景的要素是哪些。
旋转的带光照的正方体
12-15
带光照的旋转的立方体，利用opengl写的，这是课后作业，你可以根据这个程序改进，然后加上更复杂的东西实现更完美的建模效果。
音视频开发之旅（42)-光照基础(一)
yabin的专栏
04-19 317
目录 光照相关基本知识 实践 资料 收获 效果如下： 一、光照相关基本知识 经典光照模型通过单独计算光源成分得到综合光照效果，然后添加到材质表面上特定点。这些成分包括环境光(Ambient Lighting)、漫反射光(Diffuse Lighting)和镜面反射光(Specular Lighting)。 image 图片来自：基础光照 1.1 环境光（Ambient Lightiing） 环境光（Ambient Lightiing）不来自任何特定方向的光，在经典..
Pygame 围绕轴旋转立方体
09-02 558
例如，你可以在游戏中收集大量的数据（比如玩家的行为和位置），然后训练一个神经网络来预测玩家的下一个动作。这个例子中，我们使用了3x3的旋转矩阵来表示立方体的旋转。这个矩阵的每一行代表了旋转轴的方向（在我们的例子中是x和y轴），每一列代表了旋转后的每个轴上的坐标。在这个例子中，我们首先定义了一个旋转的立方体，然后在主循环中更新它的位置。在这个例子中，我们只考虑了x和y的旋转，因为我们只需要一个平面来绘制立方体。z = 0 # 在这个例子中，我们只考虑x和y的旋转。# 绘制旋转后的立方体。
教你用 Python 实现 3D 游戏引擎时，处理复杂的图形和光照效果。
2401_86187906的博客
08-09 1024
3D 游戏开发是一个复杂的领域，需要对图形学、数学（向量、矩阵等）以及相关的编程概念有深入的理解。如果要开发功能完备的 3D 游戏引擎，需要投入大量的时间和精力，并且可能需要结合多个库和技术来满足各种需求。要实现复杂的光照效果，通常需要了解光照模型的基本原理，如环境光、漫反射光、镜面反射光等，并在图形渲染中进行相应的设置。第三方库：还有一些其他的第三方库，如 Panda3D、Kivy 等，它们提供了更高级的 3D 游戏开发功能，包括图形渲染、光照、纹理映射等。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值