Changeset 508


Ignore:
Timestamp:
Nov 12, 2005, 4:14:38 PM (15 years ago)
Author:
Sam Hocevar
Message:
  • coding style fixes.
Location:
libcaca/trunk/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/src/caca.h

    r496 r508  
    365365char* caca_get_html3(void);
    366366char* caca_get_irc(void);
    367 char* caca_get_ANSI(int trailing);
     367char* caca_get_ansi(int trailing);
    368368/*  @} */
    369369
  • libcaca/trunk/src/graphics.c

    r496 r508  
    238238#if defined(USE_GL)
    239239
    240 static unsigned int const gl_bg_palette[] =
     240static unsigned int const gl_bgpal[] =
    241241{
    242242    0,
     
    303303#if defined(USE_GL)
    304304unsigned char gl_key = 0;
    305 int gl_special_key=0;
     305int gl_special_key = 0;
    306306int gl_new_width;
    307307int gl_new_height;
    308308
    309 
    310309static void gl_handle_keyboard(unsigned char key, int x, int y)
    311310{
    312311  gl_key = key;
    313312}
     313
    314314static void gl_handle_special_key(int key, int x, int y)
    315315{
    316   gl_special_key = key;
    317 }
    318 static void gl_handle_reshape (int w, int h)
    319 {
    320   if(gl_bit) /* Do not handle reshaping at the first time*/
    321     {
    322 
    323       gl_new_width = w;
    324       gl_new_height = h;
    325 
    326       gl_resized = 1;
    327     }
    328   else
    329     gl_bit=1;
    330 }
     316    gl_special_key = key;
     317}
     318
     319static void gl_handle_reshape(int w, int h)
     320{
     321    if(gl_bit) /* Do not handle reshaping at the first time*/
     322    {
     323        gl_new_width = w;
     324        gl_new_height = h;
     325
     326        gl_resized = 1;
     327    }
     328    else
     329        gl_bit = 1;
     330}
     331
    331332static void gl_handle_mouse(int button, int state, int x, int y)
    332333{
    333   gl_mouse_clicked = 1;
    334   gl_mouse_button = button;
    335   gl_mouse_state = state;
    336   gl_mouse_x = x/gl_font_width;
    337   gl_mouse_y = y/gl_font_height;
    338   gl_mouse_changed = 1;
    339 }
     334    gl_mouse_clicked = 1;
     335    gl_mouse_button = button;
     336    gl_mouse_state = state;
     337    gl_mouse_x = x / gl_font_width;
     338    gl_mouse_y = y / gl_font_height;
     339    gl_mouse_changed = 1;
     340}
     341
    340342static void gl_handle_mouse_motion(int x, int y)
    341343{
    342   gl_mouse_x = x/gl_font_width;
    343   gl_mouse_y = y/gl_font_height;
    344   gl_mouse_changed = 1;
    345 }
    346 
    347 #endif
    348 
    349 
     344    gl_mouse_x = x / gl_font_width;
     345    gl_mouse_y = y / gl_font_height;
     346    gl_mouse_changed = 1;
     347}
     348#endif
    350349
    351350/** \brief Set the default colour pair.
     
    797796        gettextinfo(&conio_ti);
    798797        conio_screen = malloc(2 * conio_ti.screenwidth
    799                                  * conio_ti.screenheight * sizeof(char));
     798                                * conio_ti.screenheight * sizeof(char));
    800799        if(conio_screen == NULL)
    801800            return -1;
     
    994993#endif
    995994#if defined(USE_GL)
    996       if(_caca_driver == CACA_DRIVER_GL)
    997         {
    998           int i;
    999           char *empty;
    1000 
    1001           if(getenv("CACA_GEOMETRY") && *(getenv("CACA_GEOMETRY")))
     995    if(_caca_driver == CACA_DRIVER_GL)
     996    {
     997        int i;
     998        char *empty;
     999
     1000        if(getenv("CACA_GEOMETRY") && *(getenv("CACA_GEOMETRY")))
    10021001            sscanf(getenv("CACA_GEOMETRY"),
    10031002                   "%ux%u", &_caca_width, &_caca_height);
     
    10081007            _caca_height = 32;
    10091008
    1010           gl_font_width = 9;
    1011           gl_font_height = 15;
    1012 
    1013           gl_width =  _caca_width*gl_font_width;
    1014           gl_height = _caca_height*gl_font_height;
    1015 
    1016           glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
    1017           glutInitWindowSize(gl_width, gl_height);
    1018           gl_window = glutCreateWindow("caca for GL");
    1019 
    1020           gluOrtho2D(0,gl_width, gl_height, 0);
    1021 
    1022           glDisable(GL_CULL_FACE);
    1023           glDisable(GL_DEPTH_TEST);
    1024 
    1025           glutKeyboardFunc(gl_handle_keyboard);
    1026           glutSpecialFunc(gl_handle_special_key);
    1027           glutReshapeFunc(gl_handle_reshape);
    1028 
    1029           glutMouseFunc(gl_handle_mouse);
    1030           glutMotionFunc(gl_handle_mouse_motion);
    1031           glutPassiveMotionFunc(gl_handle_mouse_motion);
    1032 
    1033 
    1034           glLoadIdentity();
    1035 
    1036           glMatrixMode(GL_PROJECTION);
    1037           glPushMatrix();
    1038           glLoadIdentity();
    1039           gluOrtho2D(0, gl_width, gl_height, 0);
    1040 
    1041           glMatrixMode(GL_MODELVIEW);
    1042 
    1043 
    1044           glClear(GL_COLOR_BUFFER_BIT);
    1045 
    1046 
    1047 
    1048           empty = malloc(16*16*4);
    1049           if(empty == NULL)
     1009        gl_font_width = 9;
     1010        gl_font_height = 15;
     1011
     1012        gl_width = _caca_width * gl_font_width;
     1013        gl_height = _caca_height * gl_font_height;
     1014
     1015        glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
     1016        glutInitWindowSize(gl_width, gl_height);
     1017        gl_window = glutCreateWindow("caca for GL");
     1018
     1019        gluOrtho2D(0, gl_width, gl_height, 0);
     1020
     1021        glDisable(GL_CULL_FACE);
     1022        glDisable(GL_DEPTH_TEST);
     1023
     1024        glutKeyboardFunc(gl_handle_keyboard);
     1025        glutSpecialFunc(gl_handle_special_key);
     1026        glutReshapeFunc(gl_handle_reshape);
     1027
     1028        glutMouseFunc(gl_handle_mouse);
     1029        glutMotionFunc(gl_handle_mouse_motion);
     1030        glutPassiveMotionFunc(gl_handle_mouse_motion);
     1031
     1032        glLoadIdentity();
     1033
     1034        glMatrixMode(GL_PROJECTION);
     1035        glPushMatrix();
     1036        glLoadIdentity();
     1037        gluOrtho2D(0, gl_width, gl_height, 0);
     1038
     1039        glMatrixMode(GL_MODELVIEW);
     1040
     1041        glClear(GL_COLOR_BUFFER_BIT);
     1042
     1043        empty = malloc(16 * 16 * 4);
     1044        if(empty == NULL)
    10501045            return -1;
    10511046
    1052           memset(empty, 255, 16*16*4);
    1053           glEnable(GL_TEXTURE_2D);
    1054 
    1055           for(i=0;i<94;i++)
    1056             {
    1057               glGenTextures(1,&id[i]);
    1058               glBindTexture(GL_TEXTURE_2D, id[i]);
    1059               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    1060               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    1061               glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,
    1062                            16,16,
    1063                            0, GL_RGB, GL_UNSIGNED_BYTE, empty);
    1064             }
    1065           for(i=0;i<94;i++)
    1066             {
    1067 
    1068               glDisable(GL_TEXTURE_2D);
    1069               glClear(GL_COLOR_BUFFER_BIT);
    1070 
    1071               glColor3f(1,1,1);
    1072               glRasterPos2f(0,15);
    1073               glutBitmapCharacter(GLUT_BITMAP_9_BY_15,i+32);
    1074 
    1075 
    1076               glEnable(GL_TEXTURE_2D);
    1077               glBindTexture(GL_TEXTURE_2D,id[i]);
    1078               glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, gl_height-16, 16,16, 0);
    1079 
    1080               glutMainLoopEvent();
    1081               glutPostRedisplay();
    1082             }
     1047        memset(empty, 0xff, 16 * 16 * 4);
     1048        glEnable(GL_TEXTURE_2D);
     1049
     1050        for(i = 0; i < 94; i++)
     1051        {
     1052            glGenTextures(1, &id[i]);
     1053            glBindTexture(GL_TEXTURE_2D, id[i]);
     1054            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     1055            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     1056            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,
     1057                         16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, empty);
    10831058        }
     1059
     1060        for(i = 0; i < 94; i++)
     1061        {
     1062            glDisable(GL_TEXTURE_2D);
     1063            glClear(GL_COLOR_BUFFER_BIT);
     1064
     1065            glColor3f(1, 1, 1);
     1066            glRasterPos2f(0, 15);
     1067            glutBitmapCharacter(GLUT_BITMAP_9_BY_15, i + 32);
     1068
     1069            glEnable(GL_TEXTURE_2D);
     1070            glBindTexture(GL_TEXTURE_2D, id[i]);
     1071            glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
     1072                             0, gl_height - 16, 16, 16, 0);
     1073
     1074            glutMainLoopEvent();
     1075            glutPostRedisplay();
     1076        }
     1077    }
    10841078    else
    10851079#endif
    10861080#if defined(USE_NULL)
    1087       if(_caca_driver == CACA_DRIVER_NULL)
    1088         {
    1089           if(getenv("CACA_GEOMETRY") && *(getenv("CACA_GEOMETRY")))
     1081    if(_caca_driver == CACA_DRIVER_NULL)
     1082    {
     1083        if(getenv("CACA_GEOMETRY") && *(getenv("CACA_GEOMETRY")))
    10901084            sscanf(getenv("CACA_GEOMETRY"),
    10911085                   "%ux%u", &_caca_width, &_caca_height);
    1092           if(!_caca_width)
     1086        if(!_caca_width)
    10931087            _caca_width = 80;
    1094           if(!_caca_height)
     1088        if(!_caca_height)
    10951089            _caca_height = 32;
    1096         }
    1097       else
     1090    }
     1091    else
    10981092#endif
    10991093    {
     
    11721166#endif
    11731167#if defined(USE_GL)
    1174       if(_caca_driver == CACA_DRIVER_GL)
    1175         {
    1176           glutDestroyWindow(gl_window);
    1177         }
    1178       else
     1168    if(_caca_driver == CACA_DRIVER_GL)
     1169    {
     1170        glutDestroyWindow(gl_window);
     1171    }
     1172    else
    11791173#endif
    11801174#if defined(USE_NULL)
    1181       if(_caca_driver == CACA_DRIVER_NULL)
    1182         {
    1183           /* I'm bored to write 'nothing to do'.
    1184            * So I don't.
    1185            */
    1186         }
    1187       else
     1175    if(_caca_driver == CACA_DRIVER_NULL)
     1176    {
     1177        /* Nothing to do here. */
     1178    }
     1179    else
    11881180#endif
    11891181    {
     
    12221214#endif
    12231215#if defined(USE_GL)
    1224       if(_caca_driver == CACA_DRIVER_GL)
    1225         {
    1226           glutSetWindowTitle(title);
    1227         }
    1228       else
     1216    if(_caca_driver == CACA_DRIVER_GL)
     1217    {
     1218        glutSetWindowTitle(title);
     1219    }
     1220    else
    12291221#endif
    12301222    {
     
    12621254#endif
    12631255#if defined(USE_GL)
    1264       if(_caca_driver == CACA_DRIVER_GL)
    1265         {
    1266           return gl_width;
    1267         }
    1268       else
     1256    if(_caca_driver == CACA_DRIVER_GL)
     1257    {
     1258        return gl_width;
     1259    }
     1260    else
    12691261#endif
    12701262    {
     
    13021294#endif
    13031295#if defined(USE_GL)
    1304       if(_caca_driver == CACA_DRIVER_GL)
    1305         {
    1306           return gl_height;
    1307         }
    1308       else
     1296    if(_caca_driver == CACA_DRIVER_GL)
     1297    {
     1298        return gl_height;
     1299    }
     1300    else
    13091301#endif
    13101302    {
     
    14761468#endif
    14771469#if defined(USE_GL)
    1478       if(_caca_driver == CACA_DRIVER_GL)
    1479         {
    1480           unsigned int x, y, offsetx, offsety;
    1481 
    1482 
    1483           glClear(GL_COLOR_BUFFER_BIT);
    1484 
    1485           offsety=0;
    1486                 for(y=0;y<gl_height;y+=gl_font_height)
     1470    if(_caca_driver == CACA_DRIVER_GL)
     1471    {
     1472        unsigned int x, y, offsetx, offsety;
     1473
     1474        glClear(GL_COLOR_BUFFER_BIT);
     1475
     1476        offsety=0;
     1477        for(y = 0; y < gl_height; y += gl_font_height)
     1478        {
     1479            offsetx = 0;
     1480            for(x = 0; x < gl_width; x += gl_font_width)
    14871481            {
    1488               offsetx = 0;
    1489             for(x=0;x<gl_width;x+=gl_font_width)
    1490               {
    14911482                uint8_t *attr = cache_attr + offsetx + offsety * _caca_width;
    14921483                int offset;
    14931484                float  br, bg, bb;
    1494                 offset = attr[0]>>4;
    1495 
    1496                 br = ((gl_bg_palette[offset]&0x00FF0000)>>16)/255.0f;
    1497                 bg = ((gl_bg_palette[offset]&0x0000FF00)>>8)/255.0f;
    1498                 bb = ((gl_bg_palette[offset]&0x000000FF))/255.0f;
     1485                offset = attr[0] >> 4;
     1486
     1487                br = ((gl_bgpal[offset] & 0x00FF0000) >> 16) / 255.0f;
     1488                bg = ((gl_bgpal[offset] & 0x0000FF00) >> 8) / 255.0f;
     1489                bb = ((gl_bgpal[offset] & 0x000000FF)) / 255.0f;
    14991490
    15001491                glDisable(GL_TEXTURE_2D);
    15011492                glColor3f(br, bg, bb);
    15021493                glBegin(GL_QUADS);
    1503                 glVertex2f(x,y);
    1504                 glVertex2f(x+gl_font_width,y);
    1505                 glVertex2f(x+gl_font_width,y+gl_font_height);
    1506                 glVertex2f(x,y+gl_font_height);
     1494                glVertex2f(x, y);
     1495                glVertex2f(x + gl_font_width, y);
     1496                glVertex2f(x + gl_font_width, y + gl_font_height);
     1497                glVertex2f(x, y + gl_font_height);
    15071498                glEnd();
    15081499
    1509 
    1510                   offsetx++;
    1511               }
     1500                offsetx++;
     1501            }
    15121502
    15131503            offsety++;
     1504        }
     1505
     1506        /* 2nd pass, avoids changing render state too much */
     1507        glEnable(GL_BLEND);
     1508        glEnable(GL_TEXTURE_2D);
     1509        glBlendFunc(GL_ONE, GL_ONE);
     1510
     1511        offsety = 0;
     1512        for(y = 0; y < gl_height; y += gl_font_height)
     1513        {
     1514            offsetx = 0;
     1515            for(x = 0; x < gl_width; x += gl_font_width)
     1516            {
     1517                uint8_t *attr = cache_attr + offsetx + offsety * _caca_width;
     1518                unsigned char *chr = cache_char + offsetx + offsety * _caca_width;
     1519                float fr, fg, fb;
     1520
     1521                fr = ((gl_bgpal[attr[0] & 0xf] & 0x00FF0000) >> 16) / 255.0f;
     1522                fg = ((gl_bgpal[attr[0] & 0xf] & 0x0000FF00) >> 8) / 255.0f;
     1523                fb = ((gl_bgpal[attr[0] & 0xf] & 0x000000FF)) / 255.0f;
     1524
     1525                if(chr[0] != ' ')
     1526                {
     1527                    glBindTexture(GL_TEXTURE_2D, id[chr[0]-32]);
     1528
     1529                    glColor3f(fr, fg, fb);
     1530                    glBegin(GL_QUADS);
     1531                    glTexCoord2f(0, 1);
     1532                    glVertex2f(x, y);
     1533                    glTexCoord2f(0.5, 1);
     1534                    glVertex2f(x + gl_font_width, y);
     1535                    glTexCoord2f(0.5, 0);
     1536                    glVertex2f(x + gl_font_width, y + gl_font_height);
     1537                    glTexCoord2f(0, 0);
     1538                    glVertex2f(x, y + gl_font_height);
     1539                    glEnd();
     1540                }
     1541                offsetx++;
    15141542            }
    1515 
    1516 
    1517 
    1518           /* 2nd pass, avoids changing render state too much */
    1519           glEnable(GL_BLEND);
    1520           glEnable(GL_TEXTURE_2D);
    1521           glBlendFunc(GL_ONE, GL_ONE);
    1522 
    1523           offsety=0;
    1524                 for(y=0;y<gl_height;y+=gl_font_height)
    1525             {
    1526               offsetx = 0;
    1527               for(x=0;x<gl_width;x+=gl_font_width)
    1528                 {
    1529                   uint8_t *attr = cache_attr + offsetx + offsety * _caca_width;
    1530                   unsigned char *chr = cache_char + offsetx + offsety * _caca_width;
    1531                   float fr, fg, fb;
    1532 
    1533 
    1534                   fr = ((gl_bg_palette[attr[0] & 0xf]&0x00FF0000)>>16)/255.0f;
    1535                   fg = ((gl_bg_palette[attr[0] & 0xf]&0x0000FF00)>>8)/255.0f;
    1536                   fb = ((gl_bg_palette[attr[0] & 0xf]&0x000000FF))/255.0f;
    1537 
    1538                   if(chr[0] != ' ')
    1539                     {
    1540                       glBindTexture(GL_TEXTURE_2D, id[chr[0]-32]);
    1541 
    1542                       glColor3f(fr, fg, fb);
    1543                       glBegin(GL_QUADS);
    1544                       glTexCoord2f(0,1);
    1545                       glVertex2f(x,y);
    1546                       glTexCoord2f(0.5,1);
    1547                       glVertex2f(x+gl_font_width,y);
    1548                       glTexCoord2f(0.5,0);
    1549                       glVertex2f(x+gl_font_width,y+gl_font_height);
    1550                       glTexCoord2f(0,0);
    1551                       glVertex2f(x,y+gl_font_height);
    1552                       glEnd();
    1553                     }
    1554                   offsetx++;
    1555                 }
    1556               offsety++;
    1557             }
    1558           glDisable(GL_BLEND);
    1559           glDisable(GL_TEXTURE_2D);
    1560 
    1561 
    1562 
    1563           glutMainLoopEvent();
    1564           glutSwapBuffers();
    1565           glutPostRedisplay();
     1543            offsety++;
    15661544        }
    1567 else
     1545        glDisable(GL_BLEND);
     1546        glDisable(GL_TEXTURE_2D);
     1547
     1548        glutMainLoopEvent();
     1549        glutSwapBuffers();
     1550        glutPostRedisplay();
     1551    }
     1552    else
    15681553#endif
    15691554#if defined(USE_NULL)
    1570       if(_caca_driver == CACA_DRIVER_NULL)
    1571         {
    1572           /* Do I told you about my cat ? */
    1573         }
     1555    if(_caca_driver == CACA_DRIVER_NULL)
     1556    {
     1557        /* Nothing to do here. */
     1558    }
     1559    else
    15741560#endif
    15751561    {
     
    16971683    if(_caca_driver == CACA_DRIVER_NULL)
    16981684    {
    1699       /* \_o< pOaK */
    1700       /* By the way, we should never reach this,
    1701        * as events are not handled
    1702        */
    1703     }
     1685        /* \_o< pOaK
     1686         * By the way, we should never reach this,
     1687         * as events are not handled */
     1688    }
     1689    else
    17041690#endif
    17051691    {
     
    20262012 *  This function generates and returns an ANSI representation of
    20272013 *  the current image.
    2028  *  \param trailing if 0, raw ANSI will be generated. Otherwise, you'll be able to cut/paste the result to a function like printf
     2014 *  \param trailing if 0, raw ANSI will be generated. Otherwise, you'll be
     2015 *                  able to cut/paste the result to a function like printf
    20292016 *  \return buffer containing generated ANSI codes as a big string
    20302017 */
    2031 char* caca_get_ANSI(int trailing)
    2032 {
    2033    static int const palette[] =
    2034     {
    2035       30, 34, 32, 36, 31, 35, 33, 37, /* Both lines (light and dark) are the same, */
    2036       30, 34, 32, 36, 31, 35, 33, 37, /* light colors handling is done later */
     2018char * caca_get_ansi(int trailing)
     2019{
     2020    static int const palette[] =
     2021    {
     2022        30, 34, 32, 36, 31, 35, 33, 37, /* Both lines (light and dark) are the same, */
     2023        30, 34, 32, 36, 31, 35, 33, 37, /* light colors handling is done later */
    20372024    };
    20382025 
     
    20412028 
    20422029    /* 20 bytes assumed for max length per pixel.
    2043        Add height*9 to that (zeroes color at the end and jump to next line)
    2044      */
     2030     * Add height*9 to that (zeroes color at the end and jump to next line) */
    20452031    buffer = malloc(((_caca_height*9) + (_caca_width * _caca_height * 20)) * sizeof(char));
    20462032    cur = buffer;
     
    20622048            uint8_t c = linechar[x];
    20632049
    2064             if(!trailing)
    2065               cur += sprintf(cur, "\033[");
    2066             else
    2067               cur += sprintf(cur, "\\033[");
     2050            if(!trailing)
     2051                cur += sprintf(cur, "\033[");
     2052            else
     2053                cur += sprintf(cur, "\\033[");
    20682054 
    2069             if(fg>7)
    2070               cur += sprintf(cur, "1;%d;%dm",fg,bg);
    2071             else
    2072               cur += sprintf(cur, "0;%d;%dm",fg,bg);
     2055            if(fg > 7)
     2056                cur += sprintf(cur, "1;%d;%dm",fg,bg);
     2057            else
     2058                cur += sprintf(cur, "0;%d;%dm",fg,bg);
    20732059            *cur++ = c;
    2074             if((c=='%') && trailing)
    2075               *cur++=c;
     2060            if((c == '%') && trailing)
     2061                *cur++ = c;
    20762062            prevfg = fg;
    20772063            prevbg = bg;
    20782064        }
    2079         if(!trailing)
    2080           cur += sprintf(cur, "\033[0m\n\r");
    2081         else
    2082           cur += sprintf(cur, "\\033[0m\\n\n");
    2083     }
     2065        if(!trailing)
     2066            cur += sprintf(cur, "\033[0m\n\r");
     2067        else
     2068            cur += sprintf(cur, "\\033[0m\\n\n");
     2069    }
     2070
    20842071    /* Crop to really used size */
    20852072    buffer = realloc(buffer, (strlen(buffer) + 1) * sizeof(char));
    20862073
    20872074    return buffer;
    2088 
    2089 }
     2075}
     2076
Note: See TracChangeset for help on using the changeset viewer.