你能用c语言在codeblocks中用opengl 的glut库绘制一个四阶魔方吗，三百行代码以上

当然可以，以下是一个在 Code::Blocks 中使用 OpenGL 的 GLUT 库绘制四阶魔方的示例代码。由于代码比较长，我会把代码分开来逐一解释。

#include <stdio.h>
#include <stdlib.h>
#include <GL/glut.h>

#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT 600

#define CUBE_SIZE 1.0f
#define CUBE_GAP 0.1f
#define CUBE_TOTAL_SIZE (CUBE_SIZE + CUBE_GAP)

#define ROTATE_STEP 3.0f

#define KEY_UP 101
#define KEY_DOWN 103
#define KEY_LEFT 100
#define KEY_RIGHT 102

typedef enum {
    FRONT, BACK, LEFT, RIGHT, UP, DOWN
} Direction;

typedef struct {
    GLfloat x;
    GLfloat y;
    GLfloat z;
} Point3D;

typedef struct {
    GLfloat r;
    GLfloat g;
    GLfloat b;
} ColorRGB;

typedef struct {
    Point3D pos;
    ColorRGB color;
} Cube;

static GLfloat angleX = 0.0f;
static GLfloat angleY = 0.0f;

static Cube cubes[4][4][4];

static GLfloat cameraX = 10.0f;
static GLfloat cameraY = 10.0f;
static GLfloat cameraZ = 10.0f;

static Direction currentDirection = FRONT;
static int currentLayer = 0;

static void initCubes() {
    int i, j, k;
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            for (k = 0; k < 4; k++) {
                Cube *cube = &cubes[i][j][k];
                cube->pos.x = (i - 1.5f) * CUBE_TOTAL_SIZE;
                cube->pos.y = (j - 1.5f) * CUBE_TOTAL_SIZE;
                cube->pos.z = (k - 1.5f) * CUBE_TOTAL_SIZE;
                cube->color.r = (GLfloat) i / 4.0f;
                cube->color.g = (GLfloat) j / 4.0f;
                cube->color.b = (GLfloat) k / 4.0f;
            }
        }
    }
}

static void drawCube(Cube *cube) {
    glColor3f(cube->color.r, cube->color.g, cube->color.b);
    glPushMatrix();
    glTranslatef(cube->pos.x, cube->pos.y, cube->pos.z);
    glutSolidCube(CUBE_SIZE);
    glPopMatrix();
}

static void drawCubes() {
    int i, j, k;
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            for (k = 0; k < 4; k++) {
                drawCube(&cubes[i][j][k]);
            }
        }
    }
}

static void drawAxis() {
    glBegin(GL_LINES);

    glColor3f(1.0f, 0.0f, 0.0f);
    glVertex3f(0.0f, 0.0f, 0.0f);
    glVertex3f(10.0f, 0.0f, 0.0f);

    glColor3f(0.0f, 1.0f, 0.0f);
    glVertex3f(0.0f, 0.0f, 0.0f);
    glVertex3f(0.0f, 10.0f, 0.0f);

    glColor3f(0.0f, 0.0f, 1.0f);
    glVertex3f(0.0f, 0.0f, 0.0f);
    glVertex3f(0.0f, 0.0f, 10.0f);

    glEnd();
}

static void display() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(cameraX, cameraY, cameraZ, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);

    glPushMatrix();
    glRotatef(angleX, 1.0f, 0.0f, 0.0f);
    glRotatef(angleY, 0.0f, 1.0f, 0.0f);
    drawCubes();
    glPopMatrix();

    drawAxis();

    glutSwapBuffers();
}

static void reshape(GLsizei width, GLsizei height) {
    glViewport(0, 0, width, height);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0f, (GLfloat) width / (GLfloat) height, 0.1f, 100.0f);
}

static void rotateLayer(int layer, Direction direction) {
    Cube tempCubes[4][4];
    int i, j;
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            switch (direction) {
                case FRONT:
                    tempCubes[i][j] = cubes[layer][i][j];
                    break;
                case BACK:
                    tempCubes[i][j] = cubes[layer][3 - i][3 - j];
                    break;
                case LEFT:
                    tempCubes[i][j] = cubes[3 - j][layer][3 - i];
                    break;
                case RIGHT:
                    tempCubes[i][j] = cubes[j][layer][i];
                    break;
                case UP:
                    tempCubes[i][j] = cubes[i][3 - layer][3 - j];
                    break;
                case DOWN:
                    tempCubes[i][j] = cubes[i][layer][j];
                    break;
            }
        }
    }
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            switch (direction) {
                case FRONT:
                    cubes[layer][i][j] = tempCubes[j][3 - i];
                    break;
                case BACK:
                    cubes[layer][i][j] = tempCubes[3 - j][i];
                    break;
                case LEFT:
                    cubes[3 - j][layer][3 - i] = tempCubes[i][j];
                    break;
                case RIGHT:
                    cubes[j][layer][i] = tempCubes[i][j];
                    break;
                case UP:
                    cubes[i][3 - layer][3 - j] = tempCubes[j][3 - i];
                    break;
                case DOWN:
                    cubes[i][layer][j] = tempCubes[j][3 - i];
                    break;
            }
        }
    }
}

static void rotateCurrentLayer(Direction direction) {
    rotateLayer(currentLayer, direction);
}

static void specialKey(int key, int x, int y) {
    switch (key) {
        case KEY_UP:
            angleX += ROTATE_STEP;
            break;
        case KEY_DOWN:
            angleX -= ROTATE_STEP;
            break;
        case KEY_LEFT:
            angleY += ROTATE_STEP;
            break;
        case KEY_RIGHT:
            angleY -= ROTATE_STEP;
            break;
    }
    glutPostRedisplay();
}

static void keyboard(unsigned char key, int x, int y) {
    switch (key) {
        case 'f':
            currentDirection = FRONT;
            currentLayer = 0;
            break;
        case 'b':
            currentDirection = BACK;
            currentLayer = 3;
            break;
        case 'l':
            currentDirection = LEFT;
            currentLayer = 0;
            break;
        case 'r':
            currentDirection = RIGHT;
            currentLayer = 3;
            break;
        case 'u':
            currentDirection = UP;
            currentLayer = 3;
            break;
        case 'd':
            currentDirection = DOWN;
            currentLayer = 0;
            break;
        case 'F':
            rotateCurrentLayer(FRONT);
            break;
        case 'B':
            rotateCurrentLayer(BACK);
            break;
        case 'L':
            rotateCurrentLayer(LEFT);
            break;
        case 'R':
            rotateCurrentLayer(RIGHT);
            break;
        case 'U':
            rotateCurrentLayer(UP);
            break;
        case 'D':
            rotateCurrentLayer(DOWN);
            break;
        case 'q':
            exit(0);
            break;
    }
    glutPostRedisplay();
}

int main(int argc, char **argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    glutCreateWindow("4x4x4 Rubik's Cube");

    initCubes();

    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutSpecialFunc(specialKey);
    glutKeyboardFunc(keyboard);

    glEnable(GL_DEPTH_TEST);

    glutMainLoop();

    return 0;
}

首先，我们需要定义一些常量和数据结构。在这个示例中，我们定义了窗口的大小，每个小方块的大小，旋转步长，方向和颜色等信息。我们使用一个三维数组 `cubes` 来存储所有的小方块，每个方块包含了位置和颜色信息。

接下来，我们需要实现一些绘制函数。`drawCube` 函数用于绘制一个小方块，`drawCubes` 函数用于绘制所有的小方块，`drawAxis` 函数用于绘制坐标轴。在 `display` 函数中，我们使用 OpenGL 的矩阵操作来控制摄像机位置和旋转角度，然后分别调用上述绘制函数来绘制场景。

我们还需要实现一些交互函数。`rotateLayer` 函数用于旋转一个层，`rotateCurrentLayer` 函数用于旋转当前选中的层，`specialKey` 函数用于响应特殊按键事件（如方向键），`keyboard` 函数用于响应普通按键事件（如字母键）。在 `main` 函数中，我们创建窗口并注册这些函数，然后进入主循环。

这段代码只是一个示例，可能不够完整和健壮。如果你想要学习更多关于 OpenGL 和 GLUT 的内容，可以参考一些教程和书籍，如《OpenGL Programming Guide》和《OpenGL SuperBible》等。