opengl_test.cpp

#include<windows.h>
#include <GL/glut.h>
#include <cmath>
#include <iostream>
#include<cstdlib>
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

#define MAX_PARTICLES 500
#define VACUUM_INTAKE_START 0
#define VACUUM_INTAKE_END 99

#define VACUUM_EXHAUST_START 100
#define VACUUM_EXHAUST_END 199

#define DEHUMID_INTAKE_START 200
#define DEHUMID_INTAKE_END 349

#define DEHUMID_EXHAUST_START 350
#define DEHUMID_EXHAUST_END 499


float particleLifetime = 2.0f;
bool airFlowEnabled = true;     // Airflow Animation Switch
struct Particle {
    float pos[3];
    float vel[3];
    float color[4];   // RGBA
    float size;
    float life;
    bool active;
    int type;         // 0=air, 1=dust, 2=dirt
};
Particle particles[MAX_PARTICLES];
int lastUsedParticle = 0;

// Cylinder parameters
const float RADIUS = 3.0f;
const int SLICES = 64;
// Mouse control variables
bool mouseLeftDown = false;
int mouseLastX = 0;
int mouseLastY = 0;
float cameraAngleX = 0.0f; // Vertical camera angle
float cameraAngleY = 0.0f; // Horizontal angle (A/D to adjust)
float cameraZ = 3.0f; // Camera height (W/S to adjust)
float cameraDistance = 10.0f;// Distance to origin (Q/E to adjust)
float brushRotation = 0.0f;
float wheelRotation = 0.0f;
float mopOscillation = 0.0f;
bool animationEnabled = true;
bool showText = true;

// Control point angles and related parameters for partial cylinder
float a0 = 3 * M_PI / 4.0f - M_PI / 10.0f;
float a1 = M_PI;
float a2 = 5 * M_PI / 4.0f + M_PI / 10.0f;
float r = 2.8f;      // Radius 
float width = 0.12f; // Band width

// Variables for bumper (collision barrier)
const float start1 = M_PI / 4.0f;
const float end1 = 5.0f * M_PI / 6.0f;
const float start2 = 7.0f * M_PI / 6.0f;
const float end2 = 7.0f * M_PI / 4.0f;

// Caster wheel rotation
float casterAngle = 0.0f;

// Show ground
bool showGround = true;

// Robot vacuum movement parameters
float vacuumPosX = 0.0f;
float vacuumPosY = 0.0f;
float vacuumAngle = 0.0f;

//texture
GLuint tex_floor;
GLuint tex_wall;

void drawPartialCylinder(float r, float h, float angleStart, float angleEnd) {
    int slices = SLICES * (angleEnd - angleStart) / (2.0f * M_PI);
    glBegin(GL_QUAD_STRIP);
    for (int i = 0; i <= slices; ++i) {
        float t = (float)i / slices;
        float angle = angleStart + t * (angleEnd - angleStart);
        float x = r * cos(angle);
        float y = r * sin(angle);

        // Normal vector
        glNormal3f(cos(angle), sin(angle), 0.0f);

        glVertex3f(x, y, 0);   // Point on the bottom edge
        glVertex3f(x, y, h);   // Point on the top edge
    }
    glEnd();
}

void drawDisk(float r, float z, float angleStart = 0.0f, float angleEnd = 2.0f * M_PI, int segments = SLICES) {
    // Normal vector (up or down)
    if (z >= 0.0f)
        glNormal3f(0.0f, 0.0f, 1.0f);
    else
        glNormal3f(0.0f, 0.0f, -1.0f);

    glBegin(GL_TRIANGLE_FAN);

    glVertex3f(0.0f, 0.0f, z); // Center point

    for (int i = 0; i <= segments; ++i) {
        float angle = angleStart + (float)i / segments * (angleEnd - angleStart);
        float x = r * cos(angle);
        float y = r * sin(angle);
        glVertex3f(x, y, z);
    }
    glEnd();
}

// Convert polar coordinates (angle and radius) to Cartesian (x, y) coordinates
void polarToXY(float angle, float radius, float* out) {
    out[0] = radius * cos(angle);
    out[1] = radius * sin(angle);
}

// Quadratic Bézier interpolation to get the polar angle
void bezierAngle(float t, float* outAngle) {
    float u = 1 - t;
    *outAngle = u * u * a0 + 2 * u * t * a1 + t * t * a2;
}

// Quadratic Bézier interpolation, output the derivative of the angle (tangent direction)
void bezierAngleTangent(float t, float* outTangent) {
    *outTangent = 2 * (1 - t) * (a1 - a0) + 2 * t * (a2 - a1);
}

void drawWidePolarBezierWithHoles() {
    int n = 100;
    float holeSpacing = 0.08f; // Spacing between holes

    // Draw the main band along the Bézier curve
    glColor3f(0.3f, 0.3f, 0.3f);
    glBegin(GL_QUAD_STRIP);
    for (int i = 0; i <= n; ++i) {
        float t = i / (float)n;
        float angle, dAngle;
        bezierAngle(t, &angle);// Calculate the polar angle at t
        bezierAngleTangent(t, &dAngle);// Calculate the derivative (tangent direction) at t

        float pos[2];
        polarToXY(angle, r, pos);// Convert to (x, y) coordinates

        // Compute tangent vector at this point
        float tangent[2];
        tangent[0] = -r * sin(angle) * dAngle;
        tangent[1] = r * cos(angle) * dAngle;

        // Normalize tangent and get normal direction
        float len = sqrt(tangent[0] * tangent[0] + tangent[1] * tangent[1]);
        float normal[2] = { -tangent[1] / len, tangent[0] / len };

        // Draw the two edges of the band (using the normal direction for offset)
        glVertex2f(pos[0] + normal[0] * width / 2, pos[1] + normal[1] * width / 2);
        glVertex2f(pos[0] - normal[0] * width / 2, pos[1] - normal[1] * width / 2);
    }
    glEnd();

    // Draw holes on the band
    glColor3f(0.05f, 0.05f, 0.05f);
    for (int i = 0; i <= n; i += 3) { // Draw a set of holes every 3 points
        float t = i / (float)n;
        float angle;
        bezierAngle(t, &angle);

        float pos[2];
        polarToXY(angle, r, pos);

        // Draw 3 rows of holes at each location
        for (int row = 0; row < 3; row++) {
            float rowOffset = (row - 1) * width * 0.25f;

            glPushMatrix();
            glTranslatef(pos[0], pos[1], -0.005f);

            // Offset along the normal direction
            float tangent[2];
            tangent[0] = -r * sin(angle);
            tangent[1] = r * cos(angle);
            float len = sqrt(tangent[0] * tangent[0] + tangent[1] * tangent[1]);
            float normal[2] = { -tangent[1] / len, tangent[0] / len };

            glTranslatef(normal[0] * rowOffset, normal[1] * rowOffset, 0);

            // Draw a small hole
            drawPartialCylinder(0.0125f, 0.01f, 0.0f, 2.0f * M_PI);

            glPopMatrix();
        }
    }
}

void drawVacuumBody() {
    glPushMatrix();
    // Main body - white plastic shell
    GLfloat body1_ambient[] = { 0.3f, 0.3f, 0.3f, 1.0f };
    GLfloat body1_diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
    GLfloat body1_specular[] = { 1.0f,1.0f,1.0f,1.0f };
    GLfloat body1_shininess = 60.0f;
    glMaterialfv(GL_FRONT, GL_AMBIENT, body1_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, body1_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, body1_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, body1_shininess);

    float a0 = 3.0f * M_PI / 4.0f, a1 = 5.0f * M_PI / 4.0f, a2 = 11.0f * M_PI / 4.0f;
    drawPartialCylinder(RADIUS, 0.5f, a1, a2);
    drawPartialCylinder(RADIUS, -0.1f, 0.0f, 2.0f * M_PI);
    glTranslated(0.0f, 0.0f, 0.5f);
    drawPartialCylinder(RADIUS, 0.3f, 0.0f, 2.0f * M_PI);
    glPopMatrix();

    // Internal Water Tank Structure
    float outerRadius = RADIUS; // Outer wall radius (transparent wall)
    float waterRadius = RADIUS - 0.02f; // Water radius, almost touching the outer wall
    float waterLevel = 0.35f;  // Water level (can be changed dynamically)

    // Draw the inner wall of the sector-shaped water tank
    GLfloat inner_wall_ambient[] = { 0.3f, 0.3f, 0.3f, 1.0f };
    GLfloat inner_wall_diffuse[] = { 0.7f, 0.7f, 0.7f, 1.0f };
    GLfloat inner_wall_specular[] = { 0.2f, 0.2f, 0.2f, 1.0f };
    GLfloat inner_wall_shininess = 25.0f;
    glMaterialfv(GL_FRONT, GL_AMBIENT, inner_wall_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, inner_wall_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, inner_wall_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, inner_wall_shininess);


    // Calculate the sector angle and center angle of the outer wall
    float sectorAngle = a1 - a0; // Angle size of the outer wall sector
    float centerAngle = (a0 + a1) / 2.0f; // Center angle of the outer wall sector
    // Compute angle range for the inner wall (opposite to the outer wall opening)
    float innerA0, innerA1;
    innerA0 = centerAngle + M_PI - sectorAngle / 2.0f;
    innerA1 = centerAngle + M_PI + sectorAngle / 2.0f;
    glPushMatrix();
    glTranslatef(-4.2f, 0.0f, 0.0f);
    // Draw inner wall arc
    drawPartialCylinder(RADIUS, 0.5f, innerA0, innerA1);
    glPopMatrix();
    // Draw the bottom of water tank
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, 0.0f);
    drawDisk(waterRadius, 0.0f, 0, 2 * M_PI, 32);
    glPopMatrix();
    // Draw the top of water tank
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, 0.5f);
    drawDisk(waterRadius, 0.0f, 0, 2 * M_PI, 32);
    glPopMatrix();
    // Draw internal pipes
    GLfloat pipe_ambient[] = { 0.1f, 0.1f, 0.1f, 1.0f };
    GLfloat pipe_diffuse[] = { 0.4f, 0.4f, 0.4f, 1.0f };
    GLfloat pipe_specular[] = { 0.6f, 0.6f, 0.6f, 1.0f };
    GLfloat pipe_shininess = 50.0f;
    glMaterialfv(GL_FRONT, GL_AMBIENT, pipe_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, pipe_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, pipe_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, pipe_shininess);

    // Top inlet pipe
    glPushMatrix();
    glTranslatef(-2.0f, 1.0f, 0.45f);
    drawPartialCylinder(0.018f, 0.2f, 0.0f, 2.0f * M_PI);
    glPopMatrix();

    // Bottom outlet pipe
    glPushMatrix();
    glTranslatef(-1.5f, 0.0f, 0.0f);
    drawPartialCylinder(0.015f, 0.05f, 0.0f, 2.0f * M_PI);
    drawPartialCylinder(0.022f, 0.008f, 0.0f, 2.0f * M_PI);
    drawDisk(0.022f, 0.0f);
    glPopMatrix();

    // Draw the water itself
    glEnable(GL_BLEND);
    glDepthMask(GL_FALSE);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    // Water material - blue, semi-transparent, high specular reflection
    GLfloat water_ambient[] = { 0.1f, 0.3f, 0.4f, 0.8f };
    GLfloat water_diffuse[] = { 0.2f, 0.5f, 0.9f, 0.8f };
    GLfloat water_specular[] = { 0.8f, 0.9f, 1.0f, 0.8f };
    GLfloat water_shininess = 120.0f; // High shininess for water reflection
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, water_ambient);
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, water_diffuse);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, water_specular);
    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, water_shininess);

    // Draw the sector-shaped water volume
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, 0.0f); // Water starts from the bottom
    drawPartialCylinder(waterRadius, waterLevel, a0, a1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(0.0f, 0.0f, waterLevel);
    // Draw water surface
    drawDisk(waterRadius, 0.0f, a0, a1);
    glPopMatrix();

    // draw the transparent outer shell
    // Transparent plastic material - more transparent, slightly bluish
    GLfloat tank_ambient[] = { 0.05f, 0.08f, 0.1f, 0.15f };  // Very transparent
    GLfloat tank_diffuse[] = { 0.1f, 0.2f, 0.3f, 0.15f };   // Very transparent
    GLfloat tank_specular[] = { 0.9f, 0.95f, 1.0f, 0.15f };   // High specular reflection
    GLfloat tank_shininess = 150.0f; // Very high shininess for plastic
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, tank_ambient);
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, tank_diffuse);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, tank_specular);
    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, tank_shininess);
    drawPartialCylinder(RADIUS, 0.5f, a0, a1);
    glDepthMask(GL_TRUE);
    glDisable(GL_BLEND);

    glPushMatrix();
    // Top cover - white plastic
    GLfloat body2_ambient[] = { 0.4f, 0.4f, 0.4f, 1.0f };
    GLfloat body2_diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
    GLfloat body2_specular[] = { 1.0f,1.0f,1.0f,1.0f };
    GLfloat body2_shininess = 80.0f;
    glMaterialfv(GL_FRONT, GL_AMBIENT, body2_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, body2_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, body2_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, body2_shininess);
    drawDisk(RADIUS, 0.8f);// Top cover at height 0.8f

    // Bottom cover - dark gray plastic
    GLfloat body3_ambient[] = { 0.2f, 0.2f, 0.2f, 1.0f };
    GLfloat body3_diffuse[] = { 0.5f, 0.5f, 0.5f, 1.0f };
    GLfloat body3_specular[] = { 0.8f,0.8f,0.8f,1.0f };
    GLfloat body3_shininess = 40.0f;
    glMaterialfv(GL_FRONT, GL_AMBIENT, body3_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, body3_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, body3_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, body3_shininess);
    drawDisk(RADIUS, -0.1f);// Bottom cover at height -0.1f
    glPopMatrix();
}

void drawWheel(float y, float z, float rotation) {
    glPushMatrix();
    glTranslatef(-0.7f, y, z);
    glRotatef(90.0f, 1.0f, 0.0f, 0.0f);

    glRotatef(rotation, 0.0f, 0.0f, 1.0f);

    // Wheel
    GLfloat wheel_ambient[] = { 0.02f, 0.02f, 0.02f, 1.0f };
    GLfloat wheel_diffuse[] = { 0.05f, 0.05f, 0.05f, 1.0f };
    GLfloat wheel_specular[] = { 0.1f,0.1f,0.1f,1.0f };
    GLfloat wheel_shininess = 5.0f;
    glMaterialfv(GL_FRONT, GL_AMBIENT, wheel_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, wheel_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, wheel_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, wheel_shininess);
    glutSolidTorus(0.15, 0.3, 10, 20);

    // Hub
    GLfloat hub_ambient[] = { 0.4f, 0.4f, 0.4f, 1.0f };
    GLfloat hub_diffuse[] = { 0.85f, 0.85f, 0.85f, 1.0f };
    GLfloat hub_specular[] = { 0.8f,0.8f,0.8f,1.0f };
    GLfloat hub_shininess = 80.0f;
    glMaterialfv(GL_FRONT, GL_AMBIENT, hub_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, hub_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, hub_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, hub_shininess);
    glutSolidSphere(0.2, 10, 10);

    glPopMatrix();
}

void drawMoppingPads(float oscillation) {
    // Left mopping pad
    glPushMatrix();
    glColor3f(0.8f, 0.8f, 0.8f);
    // Add small translation based on oscillation
    glTranslated(-1.0f - oscillation * 0.02f, -1.15f, -0.1f);
    drawPartialCylinder(0.1, -0.3f, 0.0f, 2.0f * M_PI);
    glPopMatrix();

    glPushMatrix();
    glColor3f(0.8f, 0.8f, 0.8f);
    glTranslatef(-1.0f - oscillation * 0.02f, -1.15f, -0.4f);
    glScalef(2.2f, 2.2f, 0.2f);
    glutSolidSphere(0.53, 20, 20);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(-1.0f - oscillation * 0.02f, -1.15f, -0.515f);
    glScalef(1.0f, 1.0f, 0.02f);
    glColor3f(0.0f, 0.0f, 0.0f);
    glutSolidSphere(0.15, 20, 20);
    glPopMatrix();

    // Right mopping pad
    glPushMatrix();
    glColor3f(0.8f, 0.8f, 0.8f);
    // Add small translation based on oscillation (opposite direction)
    glTranslated(-1.0f - oscillation * 0.02f, 1.15f, -0.1f);
    drawPartialCylinder(0.1, -0.3f, 0.0f, 2.0f * M_PI);
    glPopMatrix();

    glPushMatrix();
    glColor3f(0.8f, 0.8f, 0.8f);
    glTranslatef(-1.0f - oscillation * 0.02f, 1.15f, -0.4f);
    glScalef(2.2f, 2.2f, 0.2f);
    glutSolidSphere(0.53, 20, 20);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(-1.0f - oscillation * 0.02f, 1.15f, -0.515f);
    glScalef(1.0f, 1.0f, 0.02f);
    glColor3f(0.0f, 0.0f, 0.0f);
    glutSolidSphere(0.15, 20, 20);
    glPopMatrix();
}

void drawSideBrush(float brushRadius, float bristleLength, float rotation) {
    glPushMatrix();

    // Apply rotation around Z axis
    glRotatef(rotation, 0.0f, 0.0f, 1.0f);

    // Draw the central motor base
    glColor3f(0.2f, 0.2f, 0.2f);
    drawPartialCylinder(brushRadius * 0.3f, brushRadius * 0.15f, 0.0f, 2.0f * M_PI);
    drawDisk(brushRadius * 0.3f, 0.0f);
    drawDisk(brushRadius * 0.3f, brushRadius * 0.15f);

    // Draw the brush fixing plate
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, brushRadius * 0.15f);
    glColor3f(0.1f, 0.1f, 0.1f);
    drawPartialCylinder(brushRadius * 0.5f, brushRadius * 0.08f, 0.0f, 2.0f * M_PI);
    drawDisk(brushRadius * 0.5f, 0.0f);
    drawDisk(brushRadius * 0.5f, brushRadius * 0.08f);
    glPopMatrix();

    // Draw 3 main bristles (distributed every 120 degrees)
    glColor3f(0.3f, 0.3f, 0.3f);

    for (int arm = 0; arm < 3; arm++) {
        glPushMatrix();
        glRotatef(arm * 120.0f, 0.0f, 0.0f, 1.0f);

        // Main bristle arm
        glTranslatef(brushRadius * 0.25f, 0.0f, brushRadius * 0.2f);

        // Draw bristle segments
        for (int segment = 0; segment < 8; segment++) {
            glPushMatrix();

            float segmentRatio = (float)segment / 7.0f;
            float x = segmentRatio * bristleLength * 0.8f;
            float z = -segmentRatio * bristleLength * 0.3f; // Curve downward
            float bendAngle = segmentRatio * 20.0f; // Gradually bend

            glTranslatef(x, 0.0f, z);
            glRotatef(-bendAngle, 0.0f, 1.0f, 0.0f); // Curve upward (for aesthetics)

            // Bristle thickness decreases toward the tip
            float thickness = brushRadius * 0.05f * (1.0f - segmentRatio * 0.5f);
            glScalef(bristleLength * 0.15f, thickness, thickness);
            glutSolidCube(1.0f);

            glPopMatrix();
        }
        glPopMatrix();
    }

    // Draw additional fine bristles
    glColor3f(0.4f, 0.4f, 0.4f);

    for (int arm = 0; arm < 3; arm++) {
        for (int subBristle = 0; subBristle < 5; subBristle++) {
            glPushMatrix();
            glRotatef(arm * 120.0f + (subBristle - 2) * 8.0f, 0.0f, 0.0f, 1.0f);

            // Sub-bristle
            glTranslatef(brushRadius * 0.3f, 0.0f, brushRadius * 0.2f);

            for (int segment = 0; segment < 6; segment++) {
                glPushMatrix();

                float segmentRatio = (float)segment / 5.0f;
                float x = segmentRatio * bristleLength * 0.6f;
                float z = -segmentRatio * bristleLength * 0.25f;
                float bendAngle = segmentRatio * 15.0f;

                glTranslatef(x, 0.0f, z);
                glRotatef(-bendAngle, 0.0f, 1.0f, 0.0f);

                float thickness = brushRadius * 0.03f * (1.0f - segmentRatio * 0.6f);
                glScalef(bristleLength * 0.12f, thickness, thickness);
                glutSolidCube(1.0f);

                glPopMatrix();
            }
            glPopMatrix();
        }
    }
    glPopMatrix();
}

// Suction inlet (vacuum mouth)
void drawCenterRectangle(float w, float h) {
    float hw = w / 2.0f;
    float hh = h / 2.0f;
    glBegin(GL_QUADS);
    glVertex2f(-hw, -hh);
    glVertex2f(hw, -hh);
    glVertex2f(hw, hh);
    glVertex2f(-hw, hh);
    glEnd();
}

void drawControlPanel() {
    // Control panel on front
    glPushMatrix();
    glTranslatef(0.7f, 0.0f, 0.8f);

    // Panel background
    glColor3f(0.2f, 0.2f, 0.2f);
    glBegin(GL_QUADS);
    glNormal3f(0.0f, 0.0f, 1.0f);
    glVertex3f(-0.5f, -0.8f, 0.01f);
    glVertex3f(0.5f, -0.8f, 0.01f);
    glVertex3f(0.5f, 0.8f, 0.01f);
    glVertex3f(-0.5f, 0.8f, 0.01f);
    glEnd();

    // Display
    glColor3f(0.0f, 0.8f, 0.0f);
    glBegin(GL_QUADS);
    glVertex3f(-0.2f, -0.5f, 0.02f);
    glVertex3f(0.2f, -0.5f, 0.02f);
    glVertex3f(0.2f, 0.5f, 0.02f);
    glVertex3f(-0.2f, 0.5f, 0.02f);
    glEnd();

    // Mode selector buttons
    glColor3f(0.6f, 0.6f, 0.6f);
    for (int i = 0; i < 3; i++) {
        glPushMatrix();
        glTranslatef(0.4f, -0.5f + i * 0.5f, 0.02f);
        glutSolidSphere(0.08, 10, 10);
        glPopMatrix();
    }

    glPopMatrix();
}

void drawCasterWheel() {
    // Draw the wheel base
    GLfloat base_ambient[] = { 0.3f, 0.3f, 0.3f, 1.0f };
    GLfloat base_diffuse[] = { 0.6f, 0.6f, 0.6f, 1.0f };
    GLfloat base_specular[] = { 0.9f, 0.9f, 0.9f, 1.0f };
    GLfloat base_shininess = 50.0f;
    glMaterialfv(GL_FRONT, GL_AMBIENT, base_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, base_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, base_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, base_shininess);
    glPushMatrix();
    glTranslatef(2.5f, 0.0f, -0.06f);
    glScalef(1.5f, 1.5f, 1.3f);
    glutSolidCube(0.1f);
    glPopMatrix();

    // Draw the left wheel
    glPushMatrix();
    glTranslatef(2.5f, 0.04f, -0.35f);
    glRotatef(90.0f, 1.0f, 0.0f, 0.0f);
    // Tire material (dark rubber)
    GLfloat tire_ambient[] = { 0.02f, 0.02f, 0.02f, 1.0f };
    GLfloat tire_diffuse[] = { 0.05f, 0.05f, 0.05f, 1.0f };
    GLfloat tire_specular[] = { 0.1f, 0.1f, 0.1f, 1.0f };
    GLfloat tire_shininess = 5.0f;
    glMaterialfv(GL_FRONT, GL_AMBIENT, tire_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, tire_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, tire_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, tire_shininess);

    glutSolidTorus(0.02, 0.08, 8, 16);// Draw tire

    // Hub material (gray plastic)
    GLfloat hub_ambient[] = { 0.3f, 0.3f, 0.3f, 1.0f };
    GLfloat hub_diffuse[] = { 0.5f, 0.5f, 0.5f, 1.0f };
    GLfloat hub_specular[] = { 0.8f, 0.8f, 0.8f, 1.0f };
    GLfloat hub_shininess = 60.0f;
    glMaterialfv(GL_FRONT, GL_AMBIENT, hub_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, hub_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, hub_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, hub_shininess);

    glScalef(1.0f, 1.0f, 0.08f);
    glutSolidSphere(0.07, 10, 10);// Draw hub
    glPopMatrix();

    // Draw the right wheel
    glPushMatrix();
    glTranslatef(2.5f, -0.04f, -0.35f);
    glRotatef(90.0f, 1.0f, 0.0f, 0.0f);
    glMaterialfv(GL_FRONT, GL_AMBIENT, tire_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, tire_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, tire_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, tire_shininess);

    glutSolidTorus(0.02, 0.08, 8, 16);

    glMaterialfv(GL_FRONT, GL_AMBIENT, hub_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, hub_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, hub_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, hub_shininess);

    glScalef(1.0f, 1.0f, 0.08f);
    glutSolidSphere(0.07, 10, 10);
    glPopMatrix();

    // Draw the axle
    glPushMatrix();
    GLfloat axle_ambient[] = { 0.2f, 0.2f, 0.2f, 1.0f };
    GLfloat axle_diffuse[] = { 0.5f, 0.5f, 0.5f, 1.0f };
    GLfloat axle_specular[] = { 0.7f, 0.7f, 0.7f, 1.0f };
    GLfloat axle_shininess = 40.0f;
    glMaterialfv(GL_FRONT, GL_AMBIENT, axle_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, axle_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, axle_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, axle_shininess);

    glTranslatef(2.5f, 0.0f, -0.24f);
    glScalef(0.08, 0.08, 0.25);
    glutSolidCube(1.0f);// Draw axle
    glPopMatrix();
}

void drawSmallEmbeddedCamera(float radius) {
    glPushMatrix();
    glRotatef(-90, 0, 1, 0);  // Rotate 90° around the y-axis

    glPushMatrix();
    // Outer mounting ring
    glColor3f(0.15f, 0.15f, 0.15f);
    drawPartialCylinder(radius * 1.3f, 0.025f, 0.0f, 2.0f * M_PI);
    drawDisk(radius * 1.3f, 0.0f);
    drawDisk(radius * 1.3f, 0.025f);

    // Camera body
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, -0.012f);
    glColor3f(0.05f, 0.05f, 0.05f);
    drawPartialCylinder(radius, 0.015f, 0.0f, 2.0f * M_PI);
    drawDisk(radius, 0.0f);
    drawDisk(radius, 0.015f);
    glPopMatrix();

    // Camera lens
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, -0.02f);
    glColor3f(0.1f, 0.1f, 0.4f);
    drawPartialCylinder(radius * 0.5f, 0.008f, 0.0f, 2.0f * M_PI);
    drawDisk(radius * 0.5f, 0.008f);
    glPopMatrix();

    // Central reflection highlight
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, -0.025f);
    glColor3f(0.3f, 0.5f, 0.8f);
    glutSolidSphere(radius * 0.15f, 6, 6);
    glPopMatrix();

    glPopMatrix();
    glPopMatrix();
}

// Infrared sensor
void drawIRSensor(float radius) {
    glPushMatrix();
    glRotatef(-90, 0, 1, 0);  // Rotate 90° around the y-axis

    glPushMatrix();
    // Outer mounting ring
    glColor3f(0.2f, 0.2f, 0.2f);
    drawPartialCylinder(radius * 1.1f, 0.02f, 0.0f, 2.0f * M_PI);
    drawDisk(radius * 1.1f, 0.0f);
    drawDisk(radius * 1.1f, 0.02f);

    // Sensor body
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, -0.01f);
    glColor3f(0.1f, 0.1f, 0.1f);
    drawPartialCylinder(radius, 0.012f, 0.0f, 2.0f * M_PI);
    drawDisk(radius, 0.0f);
    drawDisk(radius, 0.012f);
    glPopMatrix();

    // Infrared emitter/receiver window
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, -0.018f);
    glColor3f(0.3f, 0.1f, 0.1f);
    drawPartialCylinder(radius * 0.6f, 0.005f, 0.0f, 2.0f * M_PI);
    drawDisk(radius * 0.6f, 0.005f);
    glPopMatrix();

    // Central reflection highlight
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, -0.02f);
    glColor3f(0.8f, 0.3f, 0.3f);
    glutSolidSphere(radius * 0.12f, 6, 6);
    glPopMatrix();

    glPopMatrix();
    glPopMatrix();
}
// Dehumidifier air intake vent
void drawIntakeVent(float width, float height) {
    glPushMatrix();
    // Main frame of the vent
    glColor3f(0.2f, 0.2f, 0.2f);
    glBegin(GL_QUADS);
    glVertex3f(-width / 2, -height / 2, 0.0f);
    glVertex3f(width / 2, -height / 2, 0.0f);
    glVertex3f(width / 2, height / 2, 0.0f);
    glVertex3f(-width / 2, height / 2, 0.0f);
    glEnd();
    // Vent grilles
    glColor3f(0.1f, 0.1f, 0.1f);
    int barCount = 8;
    float barHeight = 0.06f * height;// Thickness of each grille bar
    float gap = (height - barCount * barHeight) / (barCount + 1);
    for (int i = 0; i < barCount; i++) {
        float y = -height / 2 + gap + i * (barHeight + gap) + barHeight / 2;
        glPushMatrix();
        glTranslatef(0.0f, y, 0.01f);
        glBegin(GL_QUADS);
        glVertex3f(-0.88f * width / 2, -barHeight / 2, 0.0f);
        glVertex3f(0.88f * width / 2, -barHeight / 2, 0.0f);
        glVertex3f(0.88f * width / 2, barHeight / 2, 0.0f);
        glVertex3f(-0.88f * width / 2, barHeight / 2, 0.0f);
        glEnd();
        glPopMatrix();
    }
    glPopMatrix();
}


void drawVentSlots(float width, float height) {
    // Set black material
    GLfloat black_ambient[] = { 0.0f, 0.0f, 0.0f, 1.0f };
    GLfloat black_diffuse[] = { 0.1f, 0.1f, 0.1f, 1.0f };
    GLfloat black_specular[] = { 0.0f, 0.0f, 0.0f, 1.0f };
    GLfloat black_shininess = 5.0f;
    glMaterialfv(GL_FRONT, GL_AMBIENT, black_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, black_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, black_specular);
    glMaterialf(GL_FRONT, GL_SHININESS, black_shininess);

    int slotCount = 6; // Number of horizontal bars
    float slotThickness = 0.02f; // Thickness of each bar
    float spacing = height / slotCount; // Spacing between bars

    for (int i = 0; i < slotCount; i++) {
        float z = -height / 2 + i * spacing + spacing / 2;
        glPushMatrix();
        glTranslatef(0.0f, 0.0f, z);
        drawPartialCylinder(RADIUS + 0.01, slotThickness, 0 - M_PI / 8, M_PI / 8);
        glPopMatrix();
    }
}

// Bumper (collision protection panel)
// Close the top and bottom (draw ring sector caps)
void drawRingEndCap(float innerR, float outerR, float z, float angleStart, float angleEnd, int segments = SLICES) {
    glBegin(GL_TRIANGLE_STRIP);
    for (int i = 0; i <= segments; ++i) {
        float angle = angleStart + (float)i / segments * (angleEnd - angleStart);
        float xOuter = outerR * cos(angle);
        float yOuter = outerR * sin(angle);
        float xInner = innerR * cos(angle);
        float yInner = innerR * sin(angle);

        glNormal3f(0.0f, 0.0f, 1.0f); /// Facing up or down
        glVertex3f(xOuter, yOuter, z);
        glVertex3f(xInner, yInner, z);
    }
    glEnd();
}

// Close the front and back (draw sector side walls)
void drawEndCapWall(float innerR, float outerR, float height, float angle) {
    float x1 = innerR * cos(angle);
    float y1 = innerR * sin(angle);
    float x2 = outerR * cos(angle);
    float y2 = outerR * sin(angle);

    glBegin(GL_QUADS);
    // Set normal
    float nx = cos(angle);
    float ny = sin(angle);
    glNormal3f(nx, ny, 0.0f);

    // From bottom to top
    glVertex3f(x1, y1, 0.0f);
    glVertex3f(x2, y2, 0.0f);
    glVertex3f(x2, y2, height);
    glVertex3f(x1, y1, height);
    glEnd();
}

// Main part: connector between bumper and robot body
void drawConnector(float angle, float outerRadius, float innerRadius, float width, float height) {
    float midRadius = (outerRadius + innerRadius) / 2.0f;
    float length = outerRadius - innerRadius;

    // Start position: on the outer arc
    float x = midRadius * cos(angle);
    float y = midRadius * sin(angle);

    glPushMatrix();
    glTranslatef(x, y, height / 2.0f);                  // Place at the middle, center in height
    glRotatef(angle * 180.0f / M_PI, 0, 0, 1);          // Point toward the circle center
    glScalef(length, width, height);                    // Stretch to a bar shape
    glutSolidCube(1.0f);
    glPopMatrix();
}

void drawBumper() {
    float outerRadius = 3.3f;
    float innerRadius = 3.2f;
    float height = 0.6f;

    float start1 = M_PI / 4.0f;
    float end1 = 5 * M_PI / 6.0f;
    float start2 = 7 * M_PI / 6.0f;
    float end2 = 7 * M_PI / 4.0f;

    drawPartialCylinder(outerRadius, height, start1, end1); // Outer wall
    drawPartialCylinder(innerRadius, height, start1, end1); // Inner wall

    drawRingEndCap(innerRadius, outerRadius, 0.0f, start1, end1);// Bottom cap
    drawRingEndCap(innerRadius, outerRadius, height, start1, end1);// Top cap

    drawEndCapWall(innerRadius, outerRadius, height, start1);// Front cap
    drawEndCapWall(innerRadius, outerRadius, height, end1);// Back cap
    // Draw the other sector (second bumper segment)
    drawPartialCylinder(outerRadius, height, start2, end2);
    drawPartialCylinder(innerRadius, height, start2, end2);

    drawRingEndCap(innerRadius, outerRadius, 0.0f, start2, end2);
    drawRingEndCap(innerRadius, outerRadius, height, start2, end2);

    drawEndCapWall(innerRadius, outerRadius, height, start2);
    drawEndCapWall(innerRadius, outerRadius, height, end2);

    // Connectors between the bumper and the robot main body
    float mid1_1 = start1 + (end1 - start1) / 3.0f;
    float mid1_2 = start1 + 2.0f * (end1 - start1) / 3.0f;
    float mid2_1 = start2 + (end2 - start2) / 3.0f;
    float mid2_2 = start2 + 2.0f * (end2 - start2) / 3.0f;

    float length1 = 0.5f;  // Length toward inside
    float width1 = 0.08f;  // Width
    float height1 = 0.6f;  // Same height as bumper

    drawConnector(mid1_1, outerRadius, length1, width1, height1);
    drawConnector(mid1_2, outerRadius, length1, width1, height1);
    drawConnector(mid2_1, outerRadius, length1, width1, height1);
    drawConnector(mid2_2, outerRadius, length1, width1, height1);
}
// Initialize the particle system
void initParticles() {
    for (int i = 0; i < MAX_PARTICLES; i++) {
        particles[i].active = false;
        particles[i].life = 0.0f;
    }
}
// Modified search function to specify a range for each type
int findUnusedParticleInRange(int start, int end) {
    static int lastUsed[4] = { 0, 100, 200, 350 };// Last used position for each pool
    int poolIndex = (start == 0) ? 0 : (start == 100) ? 1 : (start == 200) ? 2 : 3;

    // Start searching from last used position
    for (int i = lastUsed[poolIndex]; i <= end; i++) {
        if (particles[i].life <= 0.0f) {
            lastUsed[poolIndex] = i;
            return i;
        }
    }
    // If not found, search from start position
    for (int i = start; i < lastUsed[poolIndex]; i++) {
        if (particles[i].life <= 0.0f) {
            lastUsed[poolIndex] = i;
            return i;
        }
    }
    // If still not found, forcibly reuse the particle with the lowest life value
    int bestIndex = start;
    float minLife = particles[start].life;
    for (int i = start; i <= end; i++) {
        if (particles[i].life < minLife) {
            minLife = particles[i].life;
            bestIndex = i;
        }
    }

    particles[bestIndex].life = 0.0f; // Forcefully reset
    particles[bestIndex].active = false;
    lastUsed[poolIndex] = bestIndex;
    return bestIndex;
}


// Modified vacuum intake particle generation function
void generateVacuumIntake(float deltaTime) {
    // Intake area
    float intakeX = 1.5f;
    float intakeWidth = 1.0f;
    float intakeDepth = 2.0f;
    float intakeHeight = -0.1f;

    int newParticles = 12;

    for (int i = 0; i < newParticles; i++) {
        int index = findUnusedParticleInRange(VACUUM_INTAKE_START, VACUUM_INTAKE_END);

        // Randomly select particle type
        int particleType = rand() % 10;
        particles[index].type = (particleType < 6) ? 0 : // 60% air
            (particleType < 9) ? 1 : // 30% dust
            2; // 10% dirt

        // Randomly generate position within the intake area
        particles[index].pos[0] = intakeX + ((float)rand() / RAND_MAX - 0.5f) * intakeWidth * 0.5f;
        particles[index].pos[1] = ((float)rand() / RAND_MAX - 0.5f) * intakeDepth;
        particles[index].pos[2] = intakeHeight - 0.3f;

        // Set particle color and size based on type
        if (particles[index].type == 0) { // Air - gray
            particles[index].color[0] = 0.7f;
            particles[index].color[1] = 0.7f;
            particles[index].color[2] = 0.7f;
            particles[index].color[3] = 0.3f + ((float)rand() / RAND_MAX) * 0.2f;
            particles[index].size = 0.03f + ((float)rand() / RAND_MAX) * 0.02f;
        }
        else if (particles[index].type == 1) { // Dust - dark gray
            particles[index].color[0] = 0.5f;
            particles[index].color[1] = 0.5f;
            particles[index].color[2] = 0.5f;
            particles[index].color[3] = 0.4f + ((float)rand() / RAND_MAX) * 0.3f;
            particles[index].size = 0.04f + ((float)rand() / RAND_MAX) * 0.03f;
        }
        else { // Dirt - black
            particles[index].color[0] = 0.2f;
            particles[index].color[1] = 0.2f;
            particles[index].color[2] = 0.2f;
            particles[index].color[3] = 0.5f + ((float)rand() / RAND_MAX) * 0.3f;
            particles[index].size = 0.05f + ((float)rand() / RAND_MAX) * 0.04f;
        }

        // Upward velocity
        particles[index].vel[0] = -0.2f;
        particles[index].vel[1] = ((float)rand() / RAND_MAX - 0.5f) * 0.2f;
        particles[index].vel[2] = 1.3f + ((float)rand() / RAND_MAX) * 0.3f;

        particles[index].life = 1.3f;
        particles[index].active = true;
    }
}

// Modified function for generating vacuum exhaust particles
void generateVacuumExhaust(float deltaTime) {
    float slotCount = 6;
    float slotThickness = 0.02f;
    float ventHeight = 0.3f;
    float spacing = ventHeight / slotCount;

    float ventX = 0.0f;
    float ventY = 0.0f;
    float ventZ = 0.3f;

    int newParticles = 12;

    for (int i = 0; i < newParticles; i++) {
        int index = findUnusedParticleInRange(VACUUM_EXHAUST_START, VACUUM_EXHAUST_END);
        // Randomly select a slot position
        int slotIndex = rand() % (int)slotCount;
        float slotZ = ventZ + (-ventHeight / 2 + slotIndex * spacing + spacing / 2);
        // Randomly select a position on the arc-shaped bar
        float arcAngle = (((float)rand() / RAND_MAX) - 0.5f) * (M_PI / 4);
        float arcRadius = RADIUS + 0.01f;
        // Compute particle starting position
        particles[index].pos[0] = ventX + arcRadius * cos(arcAngle);
        particles[index].pos[1] = ventY + arcRadius * sin(arcAngle);
        particles[index].pos[2] = slotZ;
        // Compute exhaust direction (normal)
        float normalX = cos(arcAngle);
        float normalY = sin(arcAngle);
        // Outward velocity
        particles[index].vel[0] = normalX * (1.0f + ((float)rand() / RAND_MAX) * 0.5f);
        particles[index].vel[1] = normalY * (1.0f + ((float)rand() / RAND_MAX) * 0.5f);
        particles[index].vel[2] = ((float)rand() / RAND_MAX - 0.5f) * 0.3f;
        // Exhaust is clean air - light blue-green
        particles[index].color[0] = 0.8f;
        particles[index].color[1] = 1.0f;
        particles[index].color[2] = 0.9f;
        particles[index].color[3] = 0.2f + ((float)rand() / RAND_MAX) * 0.3f;

        particles[index].type = 0;
        particles[index].size = 0.04f + ((float)rand() / RAND_MAX) * 0.03f;
        particles[index].life = 1.5f;
        particles[index].active = true;
    }
}

// Modified function for generating dehumidifier intake particles
void generateDehumidifierIntake(float deltaTime) {
    int newParticles = 8;
    for (int i = 0; i < newParticles; i++) {
        int index = findUnusedParticleInRange(DEHUMID_INTAKE_START, DEHUMID_INTAKE_END);
        // Generate in rectangular intake area
        particles[index].pos[0] = ((float)rand() / RAND_MAX - 0.5f) * 1.4f;
        particles[index].pos[1] = ((float)rand() / RAND_MAX - 0.5f) * 2.2f;
        particles[index].pos[2] = 1.0f + ((float)rand() / RAND_MAX) * 0.3f;
        // Downward motion into intake
        particles[index].vel[0] = ((float)rand() / RAND_MAX - 0.5f) * 0.2f;
        particles[index].vel[1] = ((float)rand() / RAND_MAX - 0.5f) * 0.2f;
        particles[index].vel[2] = -0.9f - ((float)rand() / RAND_MAX) * 0.4f;
        // Light blue color
        particles[index].color[0] = 0.7f;
        particles[index].color[1] = 0.8f;
        particles[index].color[2] = 1.0f;
        particles[index].color[3] = 0.5f;
        particles[index].size = 0.05f;
        particles[index].life = 1.0f;
        particles[index].active = true;
        particles[index].type = 0;
    }
}

// Modified function for generating dehumidifier exhaust particles
void generateDehumidifierExhaust(float deltaTime) {
    int newParticles = 8;

    float a0 = 3 * M_PI / 4.0f - M_PI / 10.0f;
    float a2 = 5 * M_PI / 4.0f + M_PI / 10.0f;
    float r = 2.8f;

    for (int i = 0; i < newParticles; i++) {
        int index = findUnusedParticleInRange(DEHUMID_EXHAUST_START, DEHUMID_EXHAUST_END);
        // Randomly select a point on the Bézier curve
        float t = ((float)rand() / RAND_MAX);
        float angle;
        float u = 1 - t;
        angle = u * u * a0 + 2 * u * t * M_PI + t * t * a2;

        particles[index].pos[0] = r * cos(angle);
        particles[index].pos[1] = r * sin(angle);
        particles[index].pos[2] = -0.1f;
        // Mainly diffuse in the negative x direction
        particles[index].vel[0] = -2.0f - ((float)rand() / RAND_MAX) * 0.5f;
        particles[index].vel[1] = (((float)rand() / RAND_MAX) - 0.5f) * 0.4f;
        particles[index].vel[2] = -1.1f - ((float)rand() / RAND_MAX) * 0.1f;
        // Light blue-green color
        particles[index].color[0] = 0.8f;
        particles[index].color[1] = 1.0f;
        particles[index].color[2] = 0.9f;
        particles[index].color[3] = ((float)rand() / RAND_MAX) * 0.4f + 0.1f;

        particles[index].size = ((float)rand() / RAND_MAX) * 0.08f + 0.04f;
        particles[index].life = 1.5f;
        particles[index].active = true;
        particles[index].type = 0;
    }
}

void generateAllParticles(float deltaTime) {
    if (!airFlowEnabled) return;
    // Dehumidifier intake (top)
    generateDehumidifierIntake(deltaTime);
    // Dehumidifier exhaust (rear, Bézier curve)
    generateDehumidifierExhaust(deltaTime);
    // Vacuum cleaner intake (bottom)
    generateVacuumIntake(deltaTime);
    // Vacuum cleaner exhaust (front)
    generateVacuumExhaust(deltaTime);
}

void updateAllParticles(float deltaTime) {
    generateAllParticles(deltaTime);
    // Update all particles
    for (int i = 0; i < MAX_PARTICLES; i++) {
        Particle& p = particles[i];
        if (p.life > 0.0f) {
            // Decrease lifetime
            p.life -= deltaTime / particleLifetime;
            if (p.life > 0.0f) {
                // Update position
                p.pos[0] += p.vel[0] * deltaTime;
                p.pos[1] += p.vel[1] * deltaTime;
                p.pos[2] += p.vel[2] * deltaTime;
                // Apply different physics effects based on particle type
                if (p.type > 0) {
                    p.vel[2] -= 0.5f * deltaTime; // Dust and dirt are affected by gravity
                }
                // Gradually reduce velocity (simulate drag)
                p.vel[0] *= 0.98f;
                p.vel[1] *= 0.98f;
                p.vel[2] *= 0.98f;
                // Gradually fade out (reduce alpha)
                p.color[3] = p.color[3] * (p.life > 0.8f ? 1.0f : p.life / 0.8f);
            }
            else {
                // Mark as inactive when life ends
                p.active = false;
            }
        }
    }
}

// Unified particle drawing function
void drawAllParticles() {
    if (!airFlowEnabled) return;
    // Save current state
    glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT | GL_POINT_BIT);
    glDepthMask(GL_FALSE);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glDisable(GL_LIGHTING);
    // Enable point smoothing
    glEnable(GL_POINT_SMOOTH);
    // Draw all active particles
    for (int i = 0; i < MAX_PARTICLES; i++) {
        if (particles[i].active) {
            glPointSize(particles[i].size * 100.0f); // Scale size
            glBegin(GL_POINTS);
            glColor4fv(particles[i].color);
            glVertex3fv(particles[i].pos);
            glEnd();
        }
    }
    // Restore previous state
    glDepthMask(GL_TRUE);
    glPopAttrib();
}

// Environment setup
void loadFloorTexture() {
    int width, height, nrChannels;
    unsigned char* data = stbi_load("tilefloor.jpg", &width, &height, &nrChannels, 0);
    if (data) {
        glGenTextures(1, &tex_floor);
        glBindTexture(GL_TEXTURE_2D, tex_floor);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0,
            GL_RGB, GL_UNSIGNED_BYTE, data);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        stbi_image_free(data);
    }
}

void loadWallTexture() {
    int width, height, nrChannels;
    unsigned char* data = stbi_load("wall.jpg", &width, &height, &nrChannels, 0);
    if (data) {
        glGenTextures(1, &tex_wall);
        glBindTexture(GL_TEXTURE_2D, tex_wall);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0,
            GL_RGB, GL_UNSIGNED_BYTE, data);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        stbi_image_free(data);
    }
}


void drawGround(float size = 20.0f, float z = -0.58f) {
    glDisable(GL_LIGHTING);
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, tex_floor);
    glColor3f(1.0f, 1.0f, 1.0f);
    glBegin(GL_QUADS);
    glNormal3f(0.0, 0.0, 1.0);
    glTexCoord2f(0.0f, 0.0f); glVertex3f(-size, -size, z);
    glTexCoord2f(1.0f, 0.0f); glVertex3f(size, -size, z);
    glTexCoord2f(1.0f, 1.0f); glVertex3f(size, size, z);
    glTexCoord2f(0.0f, 1.0f); glVertex3f(-size, size, z);
    glEnd();

    glDisable(GL_TEXTURE_2D);
    glEnable(GL_LIGHTING);
}

void drawWall(float size = 20.0f, float z = -0.58f) {
    glDisable(GL_LIGHTING);
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, tex_wall);
    glColor3f(1.0f, 1.0f, 1.0f);

    glBegin(GL_QUADS);
    glNormal3f(0.0, 1.0, 0.0);
    glTexCoord2f(0.0f, 0.0f); glVertex3f(-size, -size, z);
    glTexCoord2f(1.0f, 0.0f); glVertex3f(size, -size, z);
    glTexCoord2f(1.0f, 1.0f); glVertex3f(size, -size, size);
    glTexCoord2f(0.0f, 1.0f); glVertex3f(-size, -size, size);
    glEnd();

    glBegin(GL_QUADS);
    glNormal3f(1.0f, 0.0f, 0.0f);
    glTexCoord2f(0.0f, 0.0f); glVertex3f(-size, -size, z);
    glTexCoord2f(1.0f, 0.0f); glVertex3f(-size, size, z);
    glTexCoord2f(1.0f, 1.0f); glVertex3f(-size, size, size);
    glTexCoord2f(0.0f, 1.0f); glVertex3f(-size, -size, size);
    glEnd();

    glDisable(GL_TEXTURE_2D);
    glEnable(GL_LIGHTING);
}

// Shadow Matrix
void shadowMatrix(GLfloat shadowMat[16], GLfloat groundplane[4], GLfloat lightpos[4]) {
    GLfloat dot = groundplane[0] * lightpos[0] + groundplane[1] * lightpos[1] +
        groundplane[2] * lightpos[2] + groundplane[3] * lightpos[3];

    for (int i = 0; i < 16; ++i) shadowMat[i] = 0.0f;

    shadowMat[0] = dot - lightpos[0] * groundplane[0];
    shadowMat[4] = -lightpos[0] * groundplane[1];
    shadowMat[8] = -lightpos[0] * groundplane[2];
    shadowMat[12] = -lightpos[0] * groundplane[3];

    shadowMat[1] = -lightpos[1] * groundplane[0];
    shadowMat[5] = dot - lightpos[1] * groundplane[1];
    shadowMat[9] = -lightpos[1] * groundplane[2];
    shadowMat[13] = -lightpos[1] * groundplane[3];

    shadowMat[2] = -lightpos[2] * groundplane[0];
    shadowMat[6] = -lightpos[2] * groundplane[1];
    shadowMat[10] = dot - lightpos[2] * groundplane[2];
    shadowMat[14] = -lightpos[2] * groundplane[3];

    shadowMat[3] = -lightpos[3] * groundplane[0];
    shadowMat[7] = -lightpos[3] * groundplane[1];
    shadowMat[11] = -lightpos[3] * groundplane[2];
    shadowMat[15] = dot - lightpos[3] * groundplane[3];
}

// Object to be projected as a shadow
void shadowObject() {
    //vacuum body
    glPushMatrix();
    float a0 = 3.0f * M_PI / 4.0f, a1 = 5.0f * M_PI / 4.0f, a2 = 11.0f * M_PI / 4.0f;
    drawPartialCylinder(RADIUS, 0.5f, a1, a2);
    drawPartialCylinder(RADIUS, -0.1f, 0.0f, 2.0f * M_PI);
    drawPartialCylinder(RADIUS, 0.5f, a0, a1);
    glTranslatef(0.0f, 0.0f, 0.5f);
    drawPartialCylinder(RADIUS, 0.3f, 0.0f, 2.0f * M_PI);
    glPopMatrix();
    glPushMatrix();
    drawDisk(RADIUS, 0.8f);
    drawDisk(RADIUS, -0.1f);
    glPopMatrix();
    //Bumper and connector
    drawBumper();
}

void updateAnimation() {
    static float lastTime = 0.0f;
    float currentTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0f; // Convert to seconds
    float deltaTime = currentTime - lastTime;
    lastTime = currentTime;
    if (animationEnabled) {
        brushRotation -= 10.0f;
        if (brushRotation <= -360.0f)
            brushRotation += 360.0f;

        wheelRotation -= 5.0f;
        if (wheelRotation <= -360.0f)
            wheelRotation += 360.0f;

        mopOscillation = -5.0f * sin(glutGet(GLUT_ELAPSED_TIME) * 0.003f);

        updateAllParticles(deltaTime);
    }
    glutPostRedisplay();
}

void drawVacuumCleaner() {
    drawVacuumBody();

    drawWheel(2.5f, -0.1f, wheelRotation); // Right wheel
    drawWheel(-2.5f, -0.1f, wheelRotation); // Left wheel
    drawMoppingPads(mopOscillation);// Mopping pads

    drawBumper();// Bumper

    // Draw caster wheel
    glPushMatrix();
    glTranslatef(2.5f, 0.0f, -0.1f);
    glRotatef(casterAngle, 0.0f, 0.0f, 1.0f);
    glTranslatef(-2.5f, 0.0f, 0.1f);
    glTranslatef(0.0f, 0.0f, -0.1f);
    drawCasterWheel();
    glPopMatrix();
    //These parts don't need to apply material
    glEnable(GL_COLOR_MATERIAL);
    glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
    // Draw left side brush
    glPushMatrix();
    glTranslatef(2.2f, 1.5f, -0.2f);
    drawSideBrush(0.4f, 1.5f, brushRotation);
    glPopMatrix();
    // Draw right side brush
    glPushMatrix();
    glTranslatef(2.2f, -1.5f, -0.2f);
    drawSideBrush(0.4f, 1.5f, -brushRotation);
    glPopMatrix();
    // Draw vacuum intake
    glPushMatrix();
    glTranslatef(1.5f, 0.0f, -0.101f);
    drawCenterRectangle(1.0f, 2.0f);
    glPopMatrix();
    //control panel
	//control panel
    glPushMatrix();
    glTranslatef(1.2f, 0.0f, 0.0f);
    drawControlPanel();
    glPopMatrix();
    // Draw dehumidifier intake vent (top)
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, 0.802f);
    drawIntakeVent(1.6f, 2.4f);
    glPopMatrix();
    // Draw small embedded camera
    glPushMatrix();
    glTranslatef(3.0f, -0.05f, 0.6f);
    drawSmallEmbeddedCamera(0.05f);
    glPopMatrix();
    // Draw IR sensor
    glPushMatrix();
    glTranslatef(3.0f, 0.05f, 0.6f);
    drawIRSensor(0.03f);
    glPopMatrix();
    // Draw dehumidifier exhaust
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, -0.101f);
    glColor3f(0.1f, 0.5f, 0.8f);
    drawWidePolarBezierWithHoles();
    glPopMatrix();
    // Draw vacuum cleaner exhaust vent
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, 0.3f);
    drawVentSlots(0.4f, 0.3f);
    glPopMatrix();

    glDisable(GL_COLOR_MATERIAL);
	
    // Draw all air and dust particles
    drawAllParticles();
}

//title and menu
void renderBitmapString(float x, float y, void* font, const char* string) {
    glRasterPos2f(x, y);
    for (const char* c = string; *c != '\0'; ++c) {
        glutBitmapCharacter(font, *c);
    }
}

void drawText() {
    if (!showText) return;
    glDisable(GL_LIGHTING);
    glDisable(GL_DEPTH_TEST);
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    gluOrtho2D(0, 800, 0, 600); // Fit to window size
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    // Enable blending for transparent backgrounds
    glColor4f(0.0f, 0.0f, 0.0f, 0.6f); // Semi-transparent black
    glBegin(GL_QUADS);
    glVertex2f(330, 565);
    glVertex2f(490, 565);
    glVertex2f(490, 595);
    glVertex2f(330, 595);
    glEnd();
    // Draw the menu background 
    glColor4f(0.1f, 0.1f, 0.1f, 0.7f); // Semi-transparent dark gray
    glBegin(GL_QUADS);
    glVertex2f(585, 320);
    glVertex2f(795, 320);
    glVertex2f(795, 595);
    glVertex2f(585, 595);
    glEnd();
    glDisable(GL_BLEND);
    // Top title 
    glColor3f(0.9f, 0.9f, 1.0f);
    renderBitmapString(350, 570, GLUT_BITMAP_TIMES_ROMAN_24, "EcoMop Pro");
    // Top right menu
    glColor3f(0.8f, 0.8f, 0.8f);
    int baseY = 570;
    int step = 20;
    renderBitmapString(590, baseY, GLUT_BITMAP_HELVETICA_18, "Keyboard Controls:");
    renderBitmapString(590, baseY - step * 1, GLUT_BITMAP_HELVETICA_18, "W/S - Camera Up/Down");
    renderBitmapString(590, baseY - step * 2, GLUT_BITMAP_HELVETICA_18, "A/D - Camera Rotate");
    renderBitmapString(590, baseY - step * 3, GLUT_BITMAP_HELVETICA_18, "Q/E - Zoom In/Out");
    renderBitmapString(590, baseY - step * 4, GLUT_BITMAP_HELVETICA_18, "Arrow Keys - Move");
    renderBitmapString(590, baseY - step * 5, GLUT_BITMAP_HELVETICA_18, "1 - Hide/Show Ground");
    renderBitmapString(590, baseY - step * 6, GLUT_BITMAP_HELVETICA_18, "2 - Stop/Start Animation");
    renderBitmapString(590, baseY - step * 7, GLUT_BITMAP_HELVETICA_18, "3 - Particle effect");
    renderBitmapString(590, baseY - step * 8, GLUT_BITMAP_HELVETICA_18, "R - Reset View");
    renderBitmapString(590, baseY - step * 9, GLUT_BITMAP_HELVETICA_18, "H - Close Text");
    renderBitmapString(590, baseY - step * 11, GLUT_BITMAP_HELVETICA_18, "Mouse Controls:");
    renderBitmapString(590, baseY - step * 12, GLUT_BITMAP_HELVETICA_18, "Left Drag - Rotate View");
    // Close 2D drawing
    glPopMatrix();
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
}

void displayHelpHint() {
    if (showText) return;
    glDisable(GL_LIGHTING);
    glDisable(GL_DEPTH_TEST);
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    gluOrtho2D(0, 800, 0, 600);
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glColor4f(0.0f, 0.0f, 0.0f, 0.7f);
    glBegin(GL_QUADS);
    glVertex2f(10, 20);
    glVertex2f(130, 20);
    glVertex2f(130, 40);
    glVertex2f(10, 40);
    glEnd();
    glDisable(GL_BLEND);
    glColor3f(1.0f, 1.0f, 0.5f);
    renderBitmapString(20, 25, GLUT_BITMAP_HELVETICA_12, "Press 'H' for Help");
    glPopMatrix();
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
}

void init() {
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHT1);
    glEnable(GL_LIGHT2);
    glEnable(GL_NORMALIZE);
    glShadeModel(GL_SMOOTH);
    glEnable(GL_TEXTURE_2D);
    loadFloorTexture();
    loadWallTexture();

    glClearColor(0.7f, 0.75f, 0.8f, 1.0f); // Set window background color

    //light0
    GLfloat light_diffuse[4] = { 1.0f,0.95f,0.85f,1.0f };
    GLfloat light_ambient[4] = { 0.35f,0.35f,0.35f,1.0f };
    GLfloat light_specular[4] = { 0.7f,0.7f,0.7f,1.0f };
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    //light1
    GLfloat light1_diffuse[4] = { 1.0f,0.95f,0.85f,1.0f };
    GLfloat light1_ambient[4] = { 0.3f,0.3f,0.3f,1.0f };
    GLfloat light1_specular[4] = { 0.7f,0.6f,0.5f,1.0f };
    glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse);
    glLightfv(GL_LIGHT1, GL_AMBIENT, light1_ambient);
    glLightfv(GL_LIGHT1, GL_SPECULAR, light1_specular);
    //light2
    GLfloat light2_diffuse[4] = { 0.4f,0.45f,0.55f,1.0f };
    GLfloat light2_ambient[4] = { 0.1f,0.1f,0.15f,1.0f };
    GLfloat light2_specular[4] = { 0.3f,0.35f,0.4f,1.0f };
    glLightfv(GL_LIGHT2, GL_DIFFUSE, light2_diffuse);
    glLightfv(GL_LIGHT2, GL_AMBIENT, light2_ambient);
    glLightfv(GL_LIGHT2, GL_SPECULAR, light2_specular);

    initParticles();

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    glLoadIdentity();
    // Calculate camera position with both horizontal and vertical rotation
    float thetaY = cameraAngleY * M_PI / 180.0f; // Horizontal angle
    float thetaX = cameraAngleX * M_PI / 180.0f; // Vertical angle

    float camX = cameraDistance * cosf(thetaX) * cosf(thetaY);
    float camY = cameraDistance * cosf(thetaX) * sinf(thetaY);
    float camZ = cameraZ + cameraDistance * sinf(thetaX);

    gluLookAt(camX, camY, camZ, 0, 0, 0, 0, 0, 1);// z-axis is up

    // Set up lighting
    GLfloat light_pos[4] = { 6.0f,6.0f,8.0f,1.0f };
    glLightfv(GL_LIGHT0, GL_POSITION, light_pos);
    GLfloat light1_pos[4] = { -6.0f,-6.0f,8.0f,1.0f };
    glLightfv(GL_LIGHT1, GL_POSITION, light1_pos);
    GLfloat light2_pos[4] = { 4.0f,-10.0f,8.0f,1.0f };
    glLightfv(GL_LIGHT2, GL_POSITION, light2_pos);

    //Ground
    if (showGround) {
        drawGround();
        drawWall();
    }

    glPushMatrix();
    glTranslatef(vacuumPosX, vacuumPosY, 0.0f);
    glRotatef(vacuumAngle, 0.0f, 0.0f, 1.0f);
    drawVacuumCleaner();
    glPopMatrix();

    if (showGround) {
        //===== Shadow =====
        GLfloat groundPlane[4] = { 0.0f,0.0f,1.0f,0.57f };
        GLfloat shadowMat[16];
        shadowMatrix(shadowMat, groundPlane, light_pos);

        glEnable(GL_STENCIL_TEST);
        glStencilFunc(GL_ALWAYS, 1, 0xFF);
        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
        glDepthMask(GL_FALSE);
        glDisable(GL_LIGHTING);
        glPushMatrix();
        glMultMatrixf(shadowMat);

        glTranslatef(vacuumPosX, vacuumPosY, 0.0f);
        glRotatef(vacuumAngle, 0.0f, 0.0f, 1.0f);
        shadowObject();

        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
        glDepthMask(GL_TRUE);
        glEnable(GL_BLEND); //Transparency blending
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glStencilFunc(GL_EQUAL, 1, 0xFF); //Only draw when stencil is 1
        glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
        //Draw a transparent dark quad slightly above ground as the shadow receiver
        glColor4f(0.2f, 0.2f, 0.2f, 0.6f);

        float shadowZ = -0.57;
        float size = 10.0f;

        glBegin(GL_QUADS);
        glVertex3f(-size, -size, shadowZ);
        glVertex3f(size, -size, shadowZ);
        glVertex3f(size, size, shadowZ);
        glVertex3f(-size, size, shadowZ);
        glEnd();

        glEnable(GL_LIGHTING);
        glDisable(GL_STENCIL_TEST);
        glDisable(GL_BLEND);
        glPopMatrix();
    }

    drawText();
    displayHelpHint();
    glutSwapBuffers();
}

void reshape(int w, int h) {
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0, (float)w / h, 0.1, 100.0);
    glMatrixMode(GL_MODELVIEW);
}

void keyboard(unsigned char key, int x, int y) {
    if (key == 27) {  // ESC
        exit(0);
    }

    const float ANGLE_STEP = 2.5f;
    const float DIST_STEP = 0.5f;
    const float HEIGHT_STEP = 0.25f;

    switch (key) {
    case 'a': case 'A':
        cameraAngleY += ANGLE_STEP;
        if (cameraAngleY >= 360.0f) cameraAngleY -= 360.0f;
        break;
    case 'd': case 'D':
        cameraAngleY -= ANGLE_STEP;
        if (cameraAngleY < 0.0f) cameraAngleY += 360.0f;
        break;
    case 'w': case 'W':
        cameraZ += HEIGHT_STEP;
        break;
    case 's': case 'S':
        cameraZ -= HEIGHT_STEP;
        break;
    case 'q': case 'Q':
        cameraDistance -= DIST_STEP;
        if (cameraDistance < 1.0f) cameraDistance = 1.0f;
        break;
    case 'e': case 'E':
        cameraDistance += DIST_STEP;
        break;
    case 'r': case 'R':
        cameraAngleY = 0.0f;
        cameraAngleX = 0.0f;
        cameraZ = 3.0f;
        cameraDistance = 10.0f;
        casterAngle = 0.0f;
        vacuumPosX = 0.0f;
        vacuumPosY = 0.0f;
        vacuumAngle = 0.0f;
        wheelRotation = 0.0f;
        brushRotation = 0.0f;
        mopOscillation = 0.0f;
        break;
    case '1':
        showGround = !showGround;
        break;
    case '2':
        animationEnabled = !animationEnabled; // Switch animation state
        break;
    case '3': case 'P': // Switch particle effect
        airFlowEnabled = !airFlowEnabled;
        break;
    case 'h': case 'H':
        showText = !showText;
        break;
    }

    glutPostRedisplay();
}

// Mouse button callback
void mouse(int button, int state, int x, int y) {
    if (button == GLUT_LEFT_BUTTON) {
        if (state == GLUT_DOWN) {
            mouseLeftDown = true;
            mouseLastX = x;
            mouseLastY = y;
        }
        else {
            mouseLeftDown = false;
        }
    }
}

// Mouse motion callback
void motion(int x, int y) {
    if (mouseLeftDown) {
        // Calculate mouse movement
        float deltaX = (x - mouseLastX) * 0.3f;
        float deltaY = (y - mouseLastY) * 0.3f;

        // Update camera angles
        cameraAngleY -= deltaX; // Horizontal rotation
        cameraAngleX += deltaY; // Vertical rotation

        // Limit vertical angle
        if (cameraAngleX > 89.0f) cameraAngleX = 89.0f;
        if (cameraAngleX < -89.0f) cameraAngleX = -89.0f;

        // Keep horizontal angle in range
        if (cameraAngleY >= 360.0f) cameraAngleY -= 360.0f;
        if (cameraAngleY < 0.0f) cameraAngleY += 360.0f;

        // Update last position
        mouseLastX = x;
        mouseLastY = y;
        glutPostRedisplay();
    }
}
void timer(int value) {
    updateAnimation();
    glutTimerFunc(16, timer, 0); // ~60 fps
}

void specialKeys(int key, int x, int y) {
    const float moveStep = 0.1f;
    const float rotateStep = 5.0f;

    switch (key) {
    case GLUT_KEY_LEFT:
        if (casterAngle < 60.0) {
            casterAngle += 5.0f;
        }
        vacuumAngle += rotateStep;
        break;
    case GLUT_KEY_RIGHT:
        if (casterAngle > -60.0) {
            casterAngle -= 5.0f;
        }
        vacuumAngle -= rotateStep;
        break;
    case GLUT_KEY_UP:
        vacuumPosX += moveStep * cos(vacuumAngle * M_PI / 180.0f);
        vacuumPosY += moveStep * sin(vacuumAngle * M_PI / 180.0f);
        break;
    case GLUT_KEY_DOWN:
        vacuumPosX -= moveStep * cos(vacuumAngle * M_PI / 180.0f);
        vacuumPosY -= moveStep * sin(vacuumAngle * M_PI / 180.0f);
        break;
    }
    glutPostRedisplay();
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_STENCIL);
    glutInitWindowSize(800, 600);
    glutCreateWindow("EcoMop Pro");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyboard);
    glutMouseFunc(mouse);       
    glutMotionFunc(motion);
    glutSpecialFunc(specialKeys);
    glutTimerFunc(16, timer, 0);

    glutMainLoop();
    return 0;
}