C 如何绘制近前剪裁平面？_C_Opengl Es

C 如何绘制近前剪裁平面？

c opengl-es

C 如何绘制近前剪裁平面？,c,opengl-es,C,Opengl Es,我正在尝试在OpenGL中靠近前剪裁平面绘制对象。已经定义了路径，并且摄影机正在沿路径移动。现在，我想画一个用相机移动的物体，机器人并不是直接在前面的剪切平面上我在Android上使用游戏端口，并在hud.c中尝试了如下小测试功能： void draw_triangle() { set_gl_options(FOG_PLANE); glPushMatrix(); { glTranslatef(getparam_x_resolution() / 2.0,

我正在尝试在OpenGL中靠近前剪裁平面绘制对象。已经定义了路径，并且摄影机正在沿路径移动。现在，我想画一个用相机移动的物体，机器人并不是直接在前面的剪切平面上

我在Android上使用游戏端口，并在hud.c中尝试了如下小测试功能：

void draw_triangle() {
    set_gl_options(FOG_PLANE);

    glPushMatrix();
    {
        glTranslatef(getparam_x_resolution() / 2.0, getparam_y_resolution() / 2.0, -5.0);
        glBegin(GL_TRIANGLES);          // Drawing Using Triangles
        glVertex3f(0.0f, 50.0f, 0.0f);      // Top
        glVertex3f(-50.0f, -50.0f, 0.0f);   // Bottom Left
        glVertex3f(50.0f, -50.0f, 0.0f);    // Bottom Right
        glEnd();                // Finished Drawing
    }
    glPopMatrix();
}

但它不会画。我哪里做错了？如果z轴的-5.0太远，我不是shute，或者我应该为

set\u gl\u options（）

使用其他选项，也就是说，我不是shure，我不知道应该从该选项启用/禁用什么来查看3D对象：

GL_纹理_2D
GL_深度_测试
GL_CULL_面
GLU照明
GL_标准化
GL_阿尔法_试验
GL_混合物
GL_模板_试验
GL_纹理_GEN_S
GL_纹理_GEN_T
GL_颜色_材料

其他职能：

glDepthMask
glShadeModel
glDepthFunc

以下是设置摄影机视图的代码：

void update_view(player_data_t *plyr, scalar_t dt) {
    point_t view_pt;
    vector_t view_dir, up_dir, vel_dir, view_vec;
    scalar_t ycoord;
    scalar_t course_angle;
    vector_t axis;
    matrixgl_t rot_mat;
    vector_t y_vec;
    vector_t mz_vec;
    vector_t vel_proj;
    quaternion_t rot_quat;
    scalar_t speed;
    vector_t vel_cpy;
    scalar_t time_constant_mult;

    vel_cpy = plyr->vel;
    speed = normalize_vector(&vel_cpy);

    time_constant_mult =
            1.0
                    / min( 1.0,
                            max( 0.0,
                                    ( speed - NO_INTERPOLATION_SPEED ) /
                                    ( BASELINE_INTERPOLATION_SPEED - NO_INTERPOLATION_SPEED )));

    up_dir = make_vector(0, 1, 0);

    vel_dir = plyr->vel;
    normalize_vector(&vel_dir);

    course_angle = get_course_angle();

    switch (plyr->view.mode) {
    case TUXEYE: {
        .
.
.
        break;
    }
    case BEHIND: {
        /* Camera-on-a-string mode */

        /* Construct vector from player to camera */
        view_vec = make_vector(0, sin(ANGLES_TO_RADIANS(
                course_angle -
                CAMERA_ANGLE_ABOVE_SLOPE +
                PLAYER_ANGLE_IN_CAMERA )), cos(ANGLES_TO_RADIANS(
                course_angle -
                CAMERA_ANGLE_ABOVE_SLOPE +
                PLAYER_ANGLE_IN_CAMERA )));

        view_vec = scale_vector(CAMERA_DISTANCE, view_vec);

        y_vec = make_vector(0.0, 1.0, 0.0);
        mz_vec = make_vector(0.0, 0.0, -1.0);
        vel_proj = project_into_plane(y_vec, vel_dir);

        normalize_vector(&vel_proj);

        /* Rotate view_vec so that it places the camera behind player */
        rot_quat = make_rotation_quaternion(mz_vec, vel_proj);

        view_vec = rotate_vector(rot_quat, view_vec);

        /* Construct view point */
        view_pt = move_point(plyr->pos, view_vec);

        /* Make sure view point is above terrain */
        ycoord = find_y_coord(view_pt.x, view_pt.z);

        if (view_pt.y < ycoord + MIN_CAMERA_HEIGHT) {
            view_pt.y = ycoord + MIN_CAMERA_HEIGHT;
        }

        /* Interpolate view point */
        if (plyr->view.initialized) {
            /* Interpolate twice to get a second-order filter */
            int i;
            for (i = 0; i < 2; i++) {
                view_pt = interpolate_view_pos(plyr->pos, plyr->pos,
                        MAX_CAMERA_PITCH, plyr->view.pos, view_pt,
                        CAMERA_DISTANCE, dt,
                        BEHIND_ORBIT_TIME_CONSTANT * time_constant_mult);
            }
        }

        /* Make sure interpolated view point is above terrain */
        ycoord = find_y_coord(view_pt.x, view_pt.z);

        if (view_pt.y < ycoord + ABSOLUTE_MIN_CAMERA_HEIGHT) {
            view_pt.y = ycoord + ABSOLUTE_MIN_CAMERA_HEIGHT;
        }

        /* Construct view direction */
        view_vec = subtract_points(view_pt, plyr->pos);

        axis = cross_product(y_vec, view_vec);
        normalize_vector(&axis);

        make_rotation_about_vector_matrix(rot_mat, axis,
                PLAYER_ANGLE_IN_CAMERA);
        view_dir = scale_vector(-1.0, transform_vector(rot_mat, view_vec));

        /* Interpolate orientation of camera */
        if (plyr->view.initialized) {
            /* Interpolate twice to get a second-order filter */
            int i;
            for (i = 0; i < 2; i++) {
                interpolate_view_frame(plyr->view.up, plyr->view.dir, &up_dir,
                        &view_dir, dt, BEHIND_ORIENT_TIME_CONSTANT);
                up_dir = make_vector(0.0, 1.0, 0.0);
            }
        }

        break;
    }

    case FOLLOW: {
        /* Camera follows player (above and behind) */

        up_dir = make_vector(0, 1, 0);

        /* Construct vector from player to camera */
        view_vec = make_vector(0, sin(ANGLES_TO_RADIANS(
                course_angle -
                CAMERA_ANGLE_ABOVE_SLOPE +
                PLAYER_ANGLE_IN_CAMERA )), cos(ANGLES_TO_RADIANS(
                course_angle -
                CAMERA_ANGLE_ABOVE_SLOPE +
                PLAYER_ANGLE_IN_CAMERA )));
        view_vec = scale_vector(CAMERA_DISTANCE, view_vec);

        y_vec = make_vector(0.0, 1.0, 0.0);
        mz_vec = make_vector(0.0, 0.0, -1.0);
        vel_proj = project_into_plane(y_vec, vel_dir);

        normalize_vector(&vel_proj);

        /* Rotate view_vec so that it places the camera behind player */
        rot_quat = make_rotation_quaternion(mz_vec, vel_proj);

        view_vec = rotate_vector(rot_quat, view_vec);

        /* Construct view point */
        view_pt = move_point(plyr->pos, view_vec);

        /* Make sure view point is above terrain */
        ycoord = find_y_coord(view_pt.x, view_pt.z);

        if (view_pt.y < ycoord + MIN_CAMERA_HEIGHT) {
            view_pt.y = ycoord + MIN_CAMERA_HEIGHT;
        }

        /* Interpolate view point */
        if (plyr->view.initialized) {
            /* Interpolate twice to get a second-order filter */
            int i;
            for (i = 0; i < 2; i++) {
                view_pt = interpolate_view_pos(plyr->view.plyr_pos, plyr->pos,
                        MAX_CAMERA_PITCH, plyr->view.pos, view_pt,
                        CAMERA_DISTANCE, dt,
                        FOLLOW_ORBIT_TIME_CONSTANT * time_constant_mult);
            }
        }

        /* Make sure interpolate view point is above terrain */
        ycoord = find_y_coord(view_pt.x, view_pt.z);

        if (view_pt.y < ycoord + ABSOLUTE_MIN_CAMERA_HEIGHT) {
            view_pt.y = ycoord + ABSOLUTE_MIN_CAMERA_HEIGHT;
        }

        /* Construct view direction */
        view_vec = subtract_points(view_pt, plyr->pos);

        axis = cross_product(y_vec, view_vec);
        normalize_vector(&axis);

        make_rotation_about_vector_matrix(rot_mat, axis,
                PLAYER_ANGLE_IN_CAMERA);
        view_dir = scale_vector(-1.0, transform_vector(rot_mat, view_vec));

        /* Interpolate orientation of camera */
        if (plyr->view.initialized) {
            /* Interpolate twice to get a second-order filter */
            int i;
            for (i = 0; i < 2; i++) {
                interpolate_view_frame(plyr->view.up, plyr->view.dir, &up_dir,
                        &view_dir, dt, FOLLOW_ORIENT_TIME_CONSTANT);
                up_dir = make_vector(0.0, 1.0, 0.0);
            }
        }

        break;
    }

    case ABOVE: {
        /* Camera always uphill of player */

        up_dir = make_vector(0, 1, 0);

        /* Construct vector from player to camera */
        view_vec = make_vector(0, sin(ANGLES_TO_RADIANS(
                course_angle -
                CAMERA_ANGLE_ABOVE_SLOPE+
                PLAYER_ANGLE_IN_CAMERA )), cos(ANGLES_TO_RADIANS(
                course_angle -
                CAMERA_ANGLE_ABOVE_SLOPE+
                PLAYER_ANGLE_IN_CAMERA )));
        view_vec = scale_vector(CAMERA_DISTANCE, view_vec);

        /* Construct view point */
        view_pt = move_point(plyr->pos, view_vec);

        /* Make sure view point is above terrain */
        ycoord = find_y_coord(view_pt.x, view_pt.z);

        if (view_pt.y < ycoord + MIN_CAMERA_HEIGHT) {
            view_pt.y = ycoord + MIN_CAMERA_HEIGHT;
        }

        /* Construct view direction */
        view_vec = subtract_points(view_pt, plyr->pos);

        make_rotation_matrix(rot_mat, PLAYER_ANGLE_IN_CAMERA, 'x');
        view_dir = scale_vector(-1.0, transform_vector(rot_mat, view_vec));

        break;
    }

    case BIRDEYE: {
        /* Camera always uphill of player */

        up_dir = make_vector(0, 1, 0);

        /* Construct vector from player to camera */
        /*sin(ANGLES_TO_RADIANS(
                                        course_angle -
                                        CAMERA_ANGLE_ABOVE_SLOPE+
                                        PLAYER_ANGLE_IN_CAMERA ))
                                        */
        /*cos(ANGLES_TO_RADIANS(
                                                course_angle -
                                                CAMERA_ANGLE_ABOVE_SLOPE+
                                                PLAYER_ANGLE_IN_CAMERA ))
                                                */
        view_vec = make_vector(0, 3, -0.5);
        view_vec = scale_vector(CAMERA_DISTANCE, view_vec);

        /* Construct view point */
        view_pt = move_point(plyr->pos, view_vec);

        /* Make sure view point is above terrain */
        ycoord = find_y_coord(view_pt.x, view_pt.z);

        if (view_pt.y < ycoord + MIN_CAMERA_HEIGHT) {
            view_pt.y = ycoord + MIN_CAMERA_HEIGHT;
        }

        /* Construct view direction */
        view_vec = subtract_points(view_pt, plyr->pos);

        make_rotation_matrix(rot_mat, PLAYER_ANGLE_IN_CAMERA, 'x');
        view_dir = scale_vector(-1.0, transform_vector(rot_mat, view_vec));

        break;
    }
    default:
        code_not_reached();
        break;
    }

    /* Create view matrix */
    plyr->view.pos = view_pt;
    plyr->view.dir = view_dir;
    plyr->view.up = up_dir;
    plyr->view.plyr_pos = plyr->pos;
    plyr->view.initialized = True;

    setup_view_matrix(plyr);
}

void update\u视图（玩家数据\u t*plyr，标量\u t dt）{
观点；
矢量视图方向、向上方向、水平方向、视图方向；
标量坐标；
标量航向角；
矢量轴；
matrixgl\u t rot\u mat；
向量y向量；
向量t mz_vec；
向量级项目；
四元数；
标量速度；
向量级cpy；
标量时间常数；
vel_cpy=plyr->vel；
速度=标准化向量（&vel\u cpy）；
时间常数=
1
/最小值（1.0，
最大值（0.0，
（速度-无插值速度）/
（基线插值速度-无插值速度）；
up_dir=make_向量（0,1,0）；
vel_dir=plyr->vel；
规范化_向量（&vel_dir）；
航向角=获取航向角（）；
开关（plyr->视图模式）{
case TUXEYE：{
.
.
.
打破
}
背后的案例：{
/*串上摄像机模式*/
/*构建从播放器到相机的向量*/
视图向量=生成向量（0，sin）（角度到弧度(
航向角-
摄像机角度高于坡度+
播放器（摄像机中的角度），cos（角度到弧度(
航向角-
摄像机角度高于坡度+
播放机（摄像机中的角度）；
视图向量=比例向量（摄像机距离，视图向量）；
y_-vec=make_-vector（0.0,1.0,0.0）；
mz_vec=生成向量（0.0,0.0，-1.0）；
vel_proj=将_投影到_平面（y_vec，vel_dir）；
规范化_向量（&vel_proj）；
/*旋转view_vec，使其将摄像头置于播放器后面*/
rot_quat=生成旋转四元数（mz_vec，vel_proj）；
视图向量=旋转向量（旋转向量，视图向量）；
/*构造视点*/
查看点=移动点（plyr->pos，查看向量）；
/*确保视点高于地形*/
ycoord=查找y坐标（视图x，视图z）；
如果（视图位置yview.initialized）{
/*插值两次以获得二阶滤波器*/
int i；
对于（i=0；i<2；i++）{
查看位置=插入视图位置（plyr->pos，plyr->pos，
最大摄像机间距，plyr->view.pos，view\u pt，
摄像机距离，dt，
在轨道后面（时间常数*时间常数）；
}
}
/*确保插值视点位于地形上方*/
ycoord=查找y坐标（视图x，视图z）；
如果（视角ypos）；
轴=横积（y向量，视图向量）；
规范化_向量（&轴）；
围绕向量矩阵进行旋转（旋转矩阵，轴，
播放器（摄像机中的角度）；
视图方向=缩放向量（-1.0，变换向量（旋转矩阵，视图向量））；
/*摄像机内插定向*/
如果（plyr->view.initialized）{
/*插值两次以获得二阶滤波器*/
int i；
对于（i=0；i<2；i++）{
插入视图帧（plyr->view.up，plyr->view.dir和up\u dir，
&视图_dir，dt，后面_ORIENT _TIME _CONSTANT）；
up_dir=make_向量（0.0,1.0,0.0）；
}
}
打破
}
个案如下：{
/*摄像机跟随播放器（上方和后方）*/
up_dir=make_向量（0,1,0）；
/*构建从播放器到相机的向量*/
视图向量=生成向量（0，sin）（角度到弧度(
航向角-
摄像机角度高于坡度+
播放器（摄像机中的角度），cos（角度到弧度(
航向角-
摄像机角度高于坡度+
播放机（摄像机中的角度）；
视图向量=比例向量（摄像机距离，视图向量）；
y_-vec=make_-vector（0.0,1.0,0.0）；
mz_vec=生成向量（0.0,0.0，-1.0）；
vel_proj=将_投影到_平面（y_vec，vel_dir）；
规范化_向量（&vel_proj）；
/*旋转view_vec，使其将摄像头置于播放器后面*/
rot_quat=生成旋转四元数（mz_vec，vel_proj）；
视图向量=旋转向量（旋转向量，视图向量）；
/*构造视点*/
查看点=移动点（plyr->pos，查看向量）；
/*确保视点高于地形*/
ycoord=查找y坐标（视图x，视图z）；
如果（视图位置yview.initialized）{