相关疑难解决方法(0)

总是阻碍我做3D编程的一件事是无法理解数学是如何工作的.我可以使用方法和函数在编程流程中使用数学,然后它对我来说都是清晰和合乎逻辑的,但在数学符号中,我无法从它做出正面或反面.

我一直在阅读网站,观看研究所试图解释这个问题的视频,但他们都使用数学符号,我只是迷失在其中,我的思想不会将其转化为可理解的东西.我可能有缺陷.

另外,只是使用某人的代码不是我的兴趣,我想了解它背后的机制,逻辑.我很乐意使用其他人的代码,但我真的想了解它是如何工作的.

这个问题

你能用简单的术语向我解释没有数学符号,只是编程符号/函数/伪代码,如何沿所有3轴实现矩阵变换？

理想情况下我想要的是编写方法/对象的材料/理解,我可以在其中定义3个轴的角度,类似于glRotate,以旋转我所拥有的四边形/三角形的集合.(我正在尝试编写立方体形状的3D旋转而无需访问OpenGL函数来为我执行此操作,因为每次在显示列表中发生更改时,都会在一次绘制调用中完成.)

我做了什么？

我试图制作一个90度的变换函数来获得数学的悬念,但是在制作一个理论上最简单的矩阵时却完全失败了.你可以在http://jsfiddle.net/bLfg0tj8/5/看到我失败的尝试.

Vec3 = function(x,y,z) {
    this.x = x;
    this.y = y;
    this.z = z;
}
Matrix = function Matrix() {
    this.matrixPoints = new Array();    
    this.rotationPoint = new Vec3(0,0,0);
    this.rotationAngle = 90;
}
Matrix.prototype.addVector = function(vector) {
    this.matrixPoints.push(vector);
}
Matrix.prototype.setRotationPoint = function(vector) {
    this.rotationPoint = vector; 
}
Matrix.prototype.setRotationAngle = function(angle) {
    this.rotationAngle = angle;
}
Matrix.prototype.populate = function() {
    translateToOrigin =     [[1,0,0-this.rotationPoint.x],
                                  [0,1,0-this.rotationPoint.y],
                                  [0,0,0-this.rotationPoint.z]];
    rotationMatrix =         [[0,-1,0],
                                  [0,1,0],
                                  [0,0,1]];
    translateEnd …

我有一个非常基本的GLSL程序,在第一次绘制调用后无法正确更新统一值.未收到glGetError任何错误,编译和链接着色器时信息日志中未报告任何错误,并且所有统一位置均有效.

顶点着色器:

#version 120

uniform mat4 mvp;
uniform mat3 nmv;

attribute vec3 position;
attribute vec3 normal;

varying vec3 v_normal;

void main()
{
    v_normal = normalize(nmv * normal);
    gl_Position = mvp * vec4(position, 1.0);
}

片段着色器:

#version 120

uniform vec3 lightDir;
uniform vec3 lightColor;
uniform vec3 materialColor;

varying vec3 v_normal;

void main()
{
    vec3 n = normalize(v_normal);
    float nDotL = max(0.0, dot(n, lightDir));

    gl_FragColor = vec4(materialColor * lightColor * nDotL, 1.0);
}

渲染代码:

glUseProgram(program);
glUniformMatrix4fv(mvpLoc, 1, GL_FALSE, mvp);
glUniformMatrix3fv(nmvLoc, …

我正在使用 libgdx，想要制作一个常见的高斯模糊后处理效果。按照本指南，我遇到了纹理过滤的一些问题。这里是图像：

实际图像：

半径 = 1 时模糊：

半径 = 5 进行模糊处理：

在最简单的情况下，我只有一个透明的帧缓冲区对象，其中渲染了一些对象。然后我需要对此应用一些着色器效果，基本上只是模糊，然后将结果渲染到屏幕上。我还想调整模糊半径，但如果我将半径设置为大于 1，它就会看起来非常粗糙。我猜它应该与一些线性过滤一起使用，但它不在这里。所以我只需要应用相同的效果与软模糊和可配置的半径，也许还有一些其他着色器侧选项。我还尝试将线性过滤显式分配给 FBO 纹理，这不会改变任何内容。

片段着色器：

//"in" attributes from our vertex shader
varying vec4 vColor;
varying vec2 vTexCoord;

//declare uniforms
uniform sampler2D u_texture;
uniform float resolution;
uniform float radius;
uniform vec2 dir;

void main() {
    //this will be our RGBA sum
    vec4 sum = vec4(0.0);
    
    //our original texcoord for this fragment
    vec2 tc = vTexCoord;
    
    //the amount to blur, i.e. how far off center to sample from 
    //1.0 …

当我想在同一程序的不同着色器阶段使用制服时,如何指定显式统一位置？

使用自动分配时,当标识符匹配时,将不同阶段的制服分配到同一位置.但是如何使用the定义着色器中的位置

layout (location = ...)

句法？

以下引用自:https://www.opengl.org/wiki/Uniform_( GLSL)/ Explicit_Uniform_Location

将相同的统一位置分配给同一着色器或同一程序中的两个制服是非法的.即使这两个制服具有相同的名称和类型,并且在不同的着色器阶段中定义,明确地将它们分配给相同的统一位置也是不合法的; 将发生链接器错误.

以下是GLSL规范的引用:

程序中没有两个默认块统一变量可以具有相同的位置,即使它们未被使用,否则将生成编译时或链接时错误.

我正在使用OpenGL 4.3.

由于阅读代码非常庞大,我发现,制服尚未使用. 这导致以下情况:在GTX 780上,以下代码运行没有问题(虽然它似乎不应该).在Intel HD 5500板载图形芯片上,根据GL_ARB_DEBUG_OUTPUT扩展,代码在链接时产生SHADER_ID_LINK错误.它指出,均匀位置与另一个制服重叠.

顶点着色器:

#version 430 core

layout(location = 0) in vec4 vPosition;
layout(location = 2) in vec4 vTexCoord;

layout(location = 0) uniform mat4 WorldMatrix; // <-- unused in both stages

out vec4 fPosition;
out vec4 fTexCoord;

void main() { ... }

片段着色器:

#version 430 …

首先，我根本不是数学专家。请容忍我的数学错误并在必要时纠正我，我很乐意学习。

我有一个立方体，它使用带有变换的 css 动画进行旋转：matrix3d(4x4)。我还可以手动旋转立方体，将用户操作转换为相同的矩阵3d 转换。

我想要的是当用户停止交互时带有 css 的旋转立方体，从用户离开的位置开始。这是我通过获取立方体的变换矩阵 3d 值并使用乘法动态设置 css 关键帧成功完成的事情。

然而，当用户开始与立方体交互时，立方体会跳转到其最后一个已知的手动旋转点并从那里继续，因为我无法弄清楚如何从 4x4 矩阵获取 X 和 Y 轴上的旋转。

我目前正在使用以下库Rematrix，它可以帮助我从手动旋转变为 css 旋转，如上所述。

我一直在研究有关欧拉的文章，以及如何从欧拉到矩阵，反之亦然，但正如我之前提到的，我认为这就是我缺乏数学知识阻碍我的地方。我似乎无法弄清楚。

作为参考，这里是我读过的一些文章，试图解决我的问题。

• https://medium.com/@behreajj/3d-rotations-in-processing-vectors-matrices-quaternions-10e2fed5f0a3
• http://www.gregslabaugh.net/publications/euler.pdf
• https://www.learnopencv.com/rotation-matrix-to-euler-angles/
• https://css-tricks.com/get-value-of-css-rotation-through-javascript/

最后一个来源对我来说最有意义，但如果我是正确的，那么在这种情况下没有用，因为它是关于 2D 变换，而不是 3D。

我通过以下方式获取当前的matrix3d：

const style = getComputedStyle(this.element).transform
const matrix = Rematrix.parse(style)

对于手动旋转，我使用基于用户鼠标位置（positionY、positionX）的矩阵乘法。

const r1 = Rematrix.rotateX(this.positionY)
const r2 = Rematrix.rotateY(this.positionX)

const transform = [r1, r2].reduce(Rematrix.multiply)

this.element.style[userPrefix.js + 'Transform'] = Rematrix.toString(transform)

从手动旋转到 css 旋转，我使用以下函数：

const setCssAnimationKeyframes = (lastTransform, animationData) => {
  const rotationIncrement = 90

  let matrixes = [] …

我正在尝试使用Haskell/GLUT从一堆三角形中创建一个3D球体.它工作得非常好:绿色的是"我的"球体,红色的是用GLUT的renderObject Sphere完成的.当我移动相机时,我可以看到"我的"球体真的是3D,所以这很好.

那么为什么GLUT有一个很好的照明,我的没有？(我是一个新手,并不知道我在initGL中正在做什么,从Hackage的长方体包复制那些东西...)

这是代码:

module Main where

import Graphics.UI.GLUT 

main :: IO ()
main = do
  initGL
  displayCallback $= render
  mainLoop

initGL :: IO ()
initGL = do
    getArgsAndInitialize
    initialDisplayMode $= [DoubleBuffered]
    createWindow "Chip!"
    initialDisplayMode $= [ WithDepthBuffer ]
    depthFunc          $= Just Less
    clearColor         $= Color4 0 0 0 0
    light (Light 0)    $= Enabled
    lighting           $= Enabled 
    lightModelAmbient  $= Color4 0.5 0.5 0.5 1 
    diffuse (Light 0)  $= Color4 1 1 1 1
    blend              $= Enabled
    blendFunc          $= (SrcAlpha, …

如何在 Three.js 中弧形或弯曲圆柱体类型的几何体（有变形）？

我想指定这些参数：

• 弯曲开始- 弯曲开始于圆柱体高度的百分之多少
• 弯曲结束- 弯曲结束于圆柱体高度的百分之多少

• 角度- 弯曲的强度

  

我将用滑块控制它们。我的圆柱体形状是通过用户绘制的贝塞尔曲线的挤压创建的（ Three.js 中几何类的扩展）。

我还希望能够将多个弯曲效果叠加在一起。因此，弯曲可能会影响第一个零件，然后第二个弯曲可能会使圆柱体向后弯曲。

我不是最擅长数学，所以这就是为什么我要求可以在 Three.js 中完成此操作的提示或公式。我想也许我可以在中心轴上放一条线，然后用贝塞尔曲线弯曲它。从那里我可以使用线位置来影响圆柱体的顶点。这听起来是个好主意吗？

我是OpenGl的专家，因此，我正在尝试仅学习4.x的现代OpenGl。一旦完成了基础教程（例如旋转多维数据集），我就决定尝试创建一个仅处理多维数据集的基于体素的程序。该程序的目标是快速，使用有限的CPU能力和内存以及动态的，因此映射大小可以更改，并且只有在数组中表示已填充块时才绘制块。

我有一个VBO，它具有由三角形构成的多维数据集的顶点和索引。首先，如果我告诉renderGl着色器使用render函数，然后在完成后绑定VBO，则执行此循环

绘制立方体循环：

//The letter_max are the dimensions of the matrix created to store the voxel status in
// The method I use for getting and setting entries in the map are very efficient so I have not included it in this example
for(int z = -(z_max / 2); z < z_max - (z_max / 2); z++)
{
    for(int y = -(y_max / 2); y < y_max - (y_max / 2); y++)
    {
        for(int x = -(x_max / 2); x …

我正在编写一个程序在OpenGL上绘制一个立方体，并在单击鼠标时不断旋转它。在特定角度下，我可以透视立方体（透明）。我启用了深度测试，所以我不知道为什么会这样。我不确定是否已正确启用它。

#include <math.h>
#include <vector>
#include <Windows.h>
#include <gl\glut.h>

using namespace std;


void myInit() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glClearColor(0, 0, 0, 1);
    glOrtho(-2, 2, -2, 2, 2, -2);
    glMatrixMode(GL_MODELVIEW);
}

float Cube[][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} };
float Colors[][3] = { {0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 1, 0}, {0, 1, …

尽管 OpenGL 的功能很简单，但仍然让我感到困惑，但我开始学习它是如何工作的。

我正在寻找一个离屏渲染的最小示例来帮助我入门。

我的应用程序将获取一堆三角形以及有关如何相对于相机定位它们的信息，并将渲染结果保存到图像文件中。目前没有照明、材质或后期处理。

我观看了有关创建离屏上下文、创建 FBO、渲染到纹理等的教程。我不介意使用 QT，因为它方便地提供 OpenGL 工具、窗口和 QImage。据我了解，为了能够对渲染图像进行图像处理，您需要将渲染目标设置为纹理，然后使用着色器，最后将纹理读取到数组中。

试图把事情放在一起从来没有让我有一个好的起点。我要么陷入设置依赖项的困境，要么黑屏，要么盯着那些除了我需要的东西之外做了太多事情的项目。

更新1：可以正常工作了。

#include <QtGui/QGuiApplication>
#include <QtGui/QSurfaceFormat>
#include <QtGui/QOffscreenSurface>
#include <QtGui/QOpenGLFunctions_4_3_Core>
#include <QtGui/QOpenGLFramebufferObject>
#include <QtGui/QOpenGLShaderProgram>
#include <QDebug>
#include <QImage>
#include <QOpenGLBuffer>

int main(int argc, char* argv[])
{
   QGuiApplication a(argc, argv);

   QSurfaceFormat surfaceFormat;
   surfaceFormat.setMajorVersion(4);
   surfaceFormat.setMinorVersion(3);

   QOpenGLContext openGLContext;
   openGLContext.setFormat(surfaceFormat);
   openGLContext.create();
   if(!openGLContext.isValid()) return -1;

   QOffscreenSurface surface;
   surface.setFormat(surfaceFormat);
   surface.create();
   if(!surface.isValid()) return -2;

   openGLContext.makeCurrent(&surface);

   QOpenGLFunctions_4_3_Core f;
   if(!f.initializeOpenGLFunctions()) return -3;

   qDebug() << QString::fromLatin1((const char*)f.glGetString(GL_VERSION));

   QSize vpSize = QSize(100, 200);

   qDebug("Hi");

   QOpenGLFramebufferObjectFormat fboFormat;
   fboFormat.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
   QOpenGLFramebufferObject fbo(vpSize, fboFormat); …