C++ 围绕与原点不同的点旋转

我正在尝试用glTranslate/glRotate为相机编码。要实现查找/查找功能，我需要渲染空间中的所有对象围绕一个点（即“摄影机”所在的位置）旋转，该点通常与原点不同。尽管如此，事物仍在围绕原点旋转。有没有办法指定不同的点

---

编辑：添加代码

谢谢你的快速回复。似乎无论发生什么我都不能让它正常工作，所以我决定添加我的代码；如果有人能看一下并告诉我需要做哪些更改才能进行翻译/旋转/回译，我将不胜感激

#include <iostream>
#include <cmath>
#include <GLUT/GLUT.h>

const double roaming_step = .13;
double z_offset = .0;
double y_offset = .0;
double x_offset = .0;

const double angle_step = 1.5;
double angle_xz = .0;
double angle_yz = .0;

bool keyStates[256] = { false };

void drawFloor()
{
    glColor3f(1.0, 1.0, 1.0);

    glBegin(GL_QUADS);
        glVertex3f(-3.0, -1.0, 3.0);
        glVertex3f(-3.0, -1.0, -3.0);
        glVertex3f(3.0, -1.0, -3.0);
        glVertex3f(3.0, -1.0, 3.0);
    glEnd();
}

void drawBalls()
{           
    glTranslatef(-3.0, -.5, -3.0);
    glColor3f(.8, .1, .1);

    for(int i = 0; i < 3; i++)
    {
        glPushMatrix();

        glTranslatef(.0, -.5, i * 3);

        for(int j = 0; j < 3; j++)
        {
            glPushMatrix();

            glTranslatef(j * 3, .0, .0);
            glutSolidSphere(.5, 20, 20);

            glPopMatrix();
        }

        glPopMatrix();
    }
}

void keyPressed(unsigned char key, int x, int y)
{
    keyStates[key] = true;
}

void keyReleased(unsigned char key, int x, int y)
{
    keyStates[key] = false;
}

void keyboardOperations()
{   
    if(keyStates['w'])
        z_offset += roaming_step;

    if(keyStates['s'])
        z_offset -= roaming_step;

    if(keyStates['a'])
        x_offset += roaming_step;

    if(keyStates['d'])
        x_offset -= roaming_step;

    if(keyStates['i'])
    {
        angle_xz -= angle_step;

        if(angle_xz < .0)
            angle_xz += 360.0;
    }

    if(keyStates['o'])
    {
        angle_xz += angle_step;

        if(angle_xz >= 360.0)
            angle_xz -= 360.0;
    }

    if(keyStates['u'])
    {
        angle_yz -= angle_step;

        if(angle_yz < .0)
            angle_yz += 360.0;
    }

    if(keyStates['j'])
    {
        angle_yz += angle_step;

        if(angle_yz >= 360.0)
            angle_yz -= 360.0;
    }

    if(keyStates['q'])
        exit(0);
}

// I guess it has to be done in this function
// but didn't get how
void camera()
{
    glLoadIdentity();

    // Forward / Backward
    glTranslated(.0, .0, z_offset);

    // Left / Right
    glTranslated(x_offset, .0, .0);

    // XZ Rotation
    glRotated(angle_xz, .0, 1.0, .0);

    // YZ Rotation
    glRotated(angle_yz, 1.0, .0, .0);
}

void display(void)
{   
    keyboardOperations();

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    camera();

    drawFloor();
    drawBalls();

    glutSwapBuffers();
}

void reshape(int width, int height)
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    glViewport(0, 0, width, height);

    GLdouble aspect = (GLdouble) width / (GLdouble) height;
    gluPerspective(60, aspect, 1, 100);

    glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char** argv)
{   
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

    glutInitWindowSize(500, 500);
    glutInitWindowPosition(0, 0);
    glutCreateWindow("openGLtest3");
    glClearColor(.0, .0, .0, .0);

    glEnable(GL_DEPTH_TEST);
    glShadeModel(GL_FLAT);

    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(display);

    glutIgnoreKeyRepeat(true);
    glutKeyboardFunc(keyPressed);
    glutKeyboardUpFunc(keyReleased);

    glutMainLoop();

    return 0;
}

#包括
#包括
#包括
常数双漫游步数=.13；
双z_偏移=.0；
双y_偏移=.0；
双x_偏移=.0；
常数双角度步进=1.5；
双角度_xz=.0；
双角度_yz=.0；
bool keyStates[256]={false}；
空抽油池（）
{
GL3F（1.0,1.0,1.0）；
glBegin（GL_QUADS）；
glVertex3f（-3.0，-1.0,3.0）；
glVertex3f（-3.0，-1.0，-3.0）；
glVertex3f（3.0，-1.0，-3.0）；
glVertex3f（3.0，-1.0,3.0）；
格伦德（）；
}
无效退税（）
{           
glTranslatef（-3.0，-.5，-3.0）；
GL3F（.8、.1、.1）；
对于（int i=0；i<3；i++）
{
glPushMatrix（）；
glTranslatef（.0，-.5，i*3）；
对于（int j=0；j<3；j++）
{
glPushMatrix（）；
glTranslatef（j*3,0,0）；
实心球（.5,20,20）；
glPopMatrix（）；
}
glPopMatrix（）；
}
}
按下void键（无符号字符键，整数x，整数y）
{
keyStates[key]=true；
}
void键已释放（无符号字符键，整数x，整数y）
{
keyStates[key]=false；
}
无效键盘操作（）
{   
if（键状态['w']）
z_偏移+=漫游_步；
if（键状态['s']）
z_偏移-=漫游_步；
if（键状态['a']）
x_offset+=漫游_步；
if（键状态['d']）
x_偏移量-=漫游_步；
if（键状态['i']）
{
角度xz-=角度步进；
如果（角度_xz<.0）
角度_xz+=360.0；
}
if（键状态['o']）
{
角度xz+=角度步进；
如果（角度大于等于360.0）
角度_xz-=360.0；
}
if（键状态['u']）
{
角度_yz-=角度_步进；
如果（角度_yz<.0）
角度_yz+=360.0；
}
if（键状态['j']）
{
角度_yz+=角度_步进；
如果（角度_yz>=360.0）
角度_yz-=360.0；
}
if（键状态['q']）
出口（0）；
}
//我想它必须在这个函数中完成
//但我不知道怎么做
无效摄影机（）
{
glLoadIdentity（）；
//向前/向后
GLU平移（.0.0，z_偏移）；
//左/右
glTranslated（x_偏移量，.0，.0）；
//XZ旋转
gl旋转（角度_xz，.0，1.0，.0）；
//YZ旋转
gl旋转（角度_yz，1.0,0,0）；
}
作废显示（作废）
{   
键盘操作（）；
glClear（GL_颜色_缓冲_位| GL_深度_缓冲_位）；
摄像机（）；
钻台（）；
牵引杆（）；
glutSwapBuffers（）；
}
空洞重塑（整型宽度、整型高度）
{
glMatrixMode（GL_投影）；
glLoadIdentity（）；
glViewport（0，0，宽度，高度）；
GLdouble纵横比=（GLdouble）宽度/（GLdouble）高度；
透视图（60，纵横比，1100）；
glMatrixMode（GLU模型视图）；
}
int main（int argc，字符**argv）
{   
glutInit（&argc，argv）；
glutInitDisplayMode（GLUT_DOUBLE | GLUT_RGB）；
glutInitWindowSize（500500）；
glutInitWindowPosition（0,0）；
glutCreateWindow（“openGLtest3”）；
glClearColor（.0,0,0,0）；
glEnable（GLU深度试验）；
glShadeModel（GLU平面）；
glutDisplayFunc（显示器）；
GLUTREFORUNC（重塑）；
glutIdleFunc（显示）；
GLUTIGNOREKEYREPLATE（真）；
键盘功能（按键）；
glutKeyboardUpFunc（按键释放）；
glutMainLoop（）；
返回0；
}

在openGL中，

glRotation

函数以原点为参考。为了围绕一个点旋转（本例中为相机坐标），您应该将相机位置平移到原点（相应地平移所有对象），然后应用旋转功能。然后您可以将相机向后平移（与所有对象一起）

假设你的相机位置是（a，b，c），那么你的代码应该是这样的：

foreach object
{
    glPushMatrix();
    glTranslate(a,b,c);
    glRotate(...);
    glTranslate(-a,-b,-c);
    //render
    glPopMatrix();
}

---

我添加了一些代码，你能看一下吗？这是错误的转换顺序。有关正确的顺序，请参见此：。