基于opengl的RoundBox绘制(转)

最新推荐文章于 2022-10-24 20:00:25 发布
最新推荐文章于 2022-10-24 20:00:25 发布
阅读量229 收藏
点赞数
文章标签： F# C C++ C# QQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lvdong5830/article/details/83872025
版权

 

实现了16种roundBox，见图

i 

#include <cstdlib>   
#include <GL/glut.h>   
#include <cmath>   
#include <ctime>   
  
//#include "BezierLinkRender.h"   
#include "RoundBoxRender.h"   
  
//   
//global   
GLuint gColorStable[] =    
{   
    (0xFF0000), //red    
    (0xDC143C), //crimson   
    (0x9400D3), //violet   
    (0xFFA000), //orange   
    (0xFFFF00), //yellow   
    (0xFFD700), //glod   
    (0x00FF00), //green   
    (0x90FF90), //lightgreen   
    (0x006400), //darkgreen   
    (0x556B2F), //olivegreen        //very good color绿橄榄   
    (0x0000FF), //blue   
    (0x00008B), //darkblue   
    (0x4169E1), //royalblue   
    (0x5555FF), //skyblue   
    (0x191970), //midnightbue   
    (0xFF00FF), //fuchsia   
    (0x00FFFF), //aqua   
    (0xffb6c1), //pink   
    (0xFF91A4), //salmonpink   
    (0x30D5C8), //turquoise   
    (0x008080), //darkturpuoise   
    (0xA9A9A9), //gray   
    (0xD3D3D3), //lightgray   
    (0x808080)  //darkgray   
};   
  
float g_fWidth = 500;   
float g_fHeight = 500;   
float g_fDepth = 100;   
float g_fAngle = .0;   
  
int     gRoundboxtype = 0;   
//   
void renderBitmapString2D(float x, float y, void *font, char *string);   
void getColorFromTable(GLuint rgb, float vec[3]);   
  
void init(void)    
{   
    RoundBoxRender::setType(gRoundboxtype);   
    printf("%d\n", gRoundboxtype);   
  
    glClearColor (0.9, 0.9, 0.9, 0.0);   
    glShadeModel (GL_SMOOTH);   
}   
  
void display(void)   
{   
    const float slotSize = 30.f;   
    const float slotColor[] = {0.8f, 0.8f, 0.8f};   
    const float slotShadowSize = 2.0f;   
    const float slotShadowAlpha = 0.7;   
  
    glClear (GL_COLOR_BUFFER_BIT);   
    glColor3f (1.0, 1.0, 1.0);   
  
    glMatrixMode(GL_PROJECTION);   
    glLoadIdentity();   
    glOrtho(0, g_fWidth, 0, g_fHeight, 0, g_fDepth);   
    glMatrixMode(GL_MODELVIEW);   
    glLoadIdentity();   
  
    glTranslatef(80.f, 80.f, 0.f);      //整体平移   
       
    int xPos(0);   
    int yPos(0);   
    int xOffset(0);   
    int yOffset(0);   
  
    for (int i=0; i<16; i++)   
    {   
        char buffer[10] = {'\0'};   
        itoa (i,buffer,10);   
  
        int fontWidOffset = i>10 ? 12 : 5;       //估算量   
        int fontHghOffset = 10;                 //估算量   
  
        int boxSize = 60;   
           
        float colorVec[3];   
        getColorFromTable(gColorStable[i], colorVec);   
        glColor3fv(colorVec);   
        RoundBoxRender::setType(i);   
  
        yOffset = i/4;   
        xOffset = i%4;   
  
        glPushMatrix();   
        {   
            glTranslatef(xPos+xOffset*100, yPos+yOffset*100, 0.f);   
            RoundBoxRender::gl_round_box_shade(GL_POLYGON, 0, 0, boxSize, boxSize, 10, 0.3, 0);   
            glColor3f(0.f, 0.f, 0.0f);   
            renderBitmapString2D(boxSize/2-fontWidOffset, boxSize/2-fontHghOffset, GLUT_BITMAP_TIMES_ROMAN_24, buffer);   
        }glPopMatrix();   
    }   
    //glColor3f(1.0f, 1.0f, 0.0f);   
    //ui_draw_link_bezier(&gRect);   
  
    glutSwapBuffers();   
}   
  
void reshape (int w, int h)   
{   
    glViewport (0, 0, (GLsizei) w, (GLsizei) h);    
    glMatrixMode (GL_PROJECTION);   
    glLoadIdentity ();   
    gluPerspective(60,1.0,1.5,20);   
    glMatrixMode (GL_MODELVIEW);   
}   
  
void keyboard(unsigned char key, int x, int y)   
{   
    switch (key)    
    {   
    case 27:   
        exit(0);   
        break;   
    }   
    glutPostRedisplay();   
}   
  
void mouse(int button, int state, int x, int y)   
{   
    if(button==GLUT_LEFT_BUTTON)   
        switch(state)   
    {   
        case GLUT_DOWN:   
            break;   
  
        case GLUT_UP:   
            break;   
    }   
    glutPostRedisplay();   
}   
  
int main(int argc, char** argv)   
{   
    glutInit(&argc, argv);   
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);   
    glutInitWindowSize (500, 500);    
    glutInitWindowPosition (100, 100);   
    glutCreateWindow (argv[0]);   
    init ();   
    glutDisplayFunc(display);    
    glutReshapeFunc(reshape);   
    glutKeyboardFunc(keyboard);   
    glutMouseFunc( mouse );   
    glutMainLoop();   
    return 0;   
}   
  
void renderBitmapString2D(float x, float y, void *font, char *string)   
{   
    char *c;   
    // set position to start drawing fonts   
    glRasterPos2f(x, y);   
    // loop all the characters in the string   
    for (c=string; *c != '\0'; c++) {   
        glutBitmapCharacter(font, *c);   
    }   
}   
void getColorFromTable(GLuint rgb, float vec[3])   
{   
    GLubyte  r = GLubyte ((rgb >> 16) & 0xFF);   
    GLubyte  g = GLubyte ((rgb >> 8) & 0xFF);   
    GLubyte  b = GLubyte (rgb & 0xFF);   
    vec[0] = r / 255.0f;   
    vec[1] = g / 255.0f;   
    vec[2] = b / 255.0f;   
}  


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/dizuo/archive/2010/07/08/5721751.aspx

 ER_H 

#define ROUNDBOXRENDER_H   
  
// 7/8/2010 RYF   
// QQ: 546952710   
// Email: dizuo@126.com   
  
struct RoundBoxRender   
{   
    // 产生一个渐变的效果：   
    //      shadetop叠加top   
    //      shadedown叠加到down 可以为负   
    //      rad为圆角的半径   
  
    /* linear horizontal shade within button or in outline */  
    /* view2d scrollers use it */  
    static void gl_round_box_shade(int mode, float minx, float miny, float maxx, float maxy, float rad, float shadetop, float shadedown)   
    {   
        float vec[7][2]= {{0.195, 0.02}, {0.383, 0.067}, {0.55, 0.169}, {0.707, 0.293},   
        {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805}};   
        float div= maxy-miny;   
        float coltop[3], coldown[3], color[4];   
        int a;   
  
        /* mult */  
        for(a=0; a<7; a++) {   
            vec[a][0]*= rad; vec[a][1]*= rad;   
        }   
        /* get current color, needs to be outside of glBegin/End */  
        glGetFloatv(GL_CURRENT_COLOR, color);   
  
        /* 'shade' defines strength of shading */      
        coltop[0]= color[0]+shadetop; if(coltop[0]>1.0) coltop[0]= 1.0;   
        coltop[1]= color[1]+shadetop; if(coltop[1]>1.0) coltop[1]= 1.0;   
        coltop[2]= color[2]+shadetop; if(coltop[2]>1.0) coltop[2]= 1.0;   
        coldown[0]= color[0]+shadedown; if(coldown[0]<0.0) coldown[0]= 0.0;   
        coldown[1]= color[1]+shadedown; if(coldown[1]<0.0) coldown[1]= 0.0;   
        coldown[2]= color[2]+shadedown; if(coldown[2]<0.0) coldown[2]= 0.0;   
  
        glShadeModel(GL_SMOOTH);   
        glBegin(mode);   
  
        /* start with corner right-bottom */  
        if(roundboxtype & 4) {   
  
            round_box_shade_col(coltop, coldown, 0.0);   
            glVertex2f(maxx-rad, miny);   
  
            for(a=0; a<7; a++) {   
                round_box_shade_col(coltop, coldown, vec[a][1]/div);   
                glVertex2f(maxx-rad+vec[a][0], miny+vec[a][1]);   
            }   
  
            round_box_shade_col(coltop, coldown, rad/div);   
            glVertex2f(maxx, miny+rad);   
        }   
        else {   
            round_box_shade_col(coltop, coldown, 0.0);   
            glVertex2f(maxx, miny);   
        }   
  
        /* corner right-top */  
        if(roundboxtype & 2) {   
  
            round_box_shade_col(coltop, coldown, (div-rad)/div);   
            glVertex2f(maxx, maxy-rad);   
  
            for(a=0; a<7; a++) {   
                round_box_shade_col(coltop, coldown, (div-rad+vec[a][1])/div);   
                glVertex2f(maxx-vec[a][1], maxy-rad+vec[a][0]);   
            }   
            round_box_shade_col(coltop, coldown, 1.0);   
            glVertex2f(maxx-rad, maxy);   
        }   
        else {   
            round_box_shade_col(coltop, coldown, 1.0);   
            glVertex2f(maxx, maxy);   
        }   
  
        /* corner left-top */  
        if(roundboxtype & 1) {   
  
            round_box_shade_col(coltop, coldown, 1.0);   
            glVertex2f(minx+rad, maxy);   
  
            for(a=0; a<7; a++) {   
                round_box_shade_col(coltop, coldown, (div-vec[a][1])/div);   
                glVertex2f(minx+rad-vec[a][0], maxy-vec[a][1]);   
            }   
  
            round_box_shade_col(coltop, coldown, (div-rad)/div);   
            glVertex2f(minx, maxy-rad);   
        }   
        else {   
            round_box_shade_col(coltop, coldown, 1.0);   
            glVertex2f(minx, maxy);   
        }   
  
        /* corner left-bottom */  
        if(roundboxtype & 8) {   
  
            round_box_shade_col(coltop, coldown, rad/div);   
            glVertex2f(minx, miny+rad);   
  
            for(a=0; a<7; a++) {   
                round_box_shade_col(coltop, coldown, (rad-vec[a][1])/div);   
                glVertex2f(minx+vec[a][1], miny+rad-vec[a][0]);   
            }   
  
            round_box_shade_col(coltop, coldown, 0.0);   
            glVertex2f(minx+rad, miny);   
        }   
        else {   
            round_box_shade_col(coltop, coldown, 0.0);   
            glVertex2f(minx, miny);   
        }   
  
        glEnd();   
        glShadeModel(GL_FLAT);   
    }   
  
    static void setType(int nType){    
        roundboxtype = nType % 16;   
    }   
  
protected:   
    static void round_box_shade_col(float *col1, float *col2, float fac)   
    {   
        float col[3];   
  
        col[0]= (fac*col1[0] + (1.0-fac)*col2[0]);   
        col[1]= (fac*col1[1] + (1.0-fac)*col2[1]);   
        col[2]= (fac*col1[2] + (1.0-fac)*col2[2]);   
  
        glColor3fv(col);   
    }   
  
    static int roundboxtype;   
};   
  
int RoundBoxRender::roundboxtype = 3;   
  
#endif  


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/dizuo/archive/2010/07/08/5721751.aspx
lvdong5830
关注
计算机图形学之OpenGL基础图形函数使用及基本图素的生成算法实现
Heavn的博客
06-05 1859
实验要求 设计一个二维卡通任务交互设计系统，实现直线，多边形绘制算法（橡皮筋效果），实现基于鼠标交互的卡通人物设计与绘制。使用颜色填充与反走样技术对卡通人物外貌以及衣着进行绘制。实现对卡通人物轮廓的交互控制，点击鼠标左键可以对人物五官位置进行拖拽移动调整。点击鼠标右键可以对卡通人物进行放缩等操作。 实验结果 本项目分为两个模式 一个是画板模式 一个是卡通人物交互模式 画板模式下可选择 画点 ...
基于opengl的曲线绘制示例
10-15
基于opengl的曲线绘制示例，缺点是，没有画出坐标轴。可以参考https://blog.csdn.net/liji_digital/article/details/78473568 来添加坐标轴
OpenGL: RoundBox绘制
Augusdi的专栏
02-26 2139
实现了16种roundBox，见图 核心绘制码在RoundBox.h文件：#ifndef ROUNDBOXRENDER_H #define ROUNDBOXRENDER_H // 7/8/2010 RYF // QQ: 546952710 // Email: dizuo@126.com struct RoundBoxRender { // 产生一个渐变的效果： // shadetop叠加to
基于opengl的RoundBox绘制
dizuo的专栏
07-08 3240
opengl RoundBox
C++用opengl直接调用box2D 的debug绘图
shenmifangke的专栏
07-14 1245
本来用的是opengl 但是debug绘图需要freeGlut 辛苦找了半天放上了 发现和本身的重名了，怎么办的呢 后来发现自带的Render中有这么一段 #include "Render.h" #ifdef __APPLE__ #include #else #include "freeglut.h" #endif #include #include
OpenGL学习之绘制立方图
zhouzhouzf的专栏
09-11 2153
首先我从网上看到一个程序，现在跟大家分享一下，该陈
opengl.rar_OPENgl 管道_opengl绘制_opengl绘制管道_管道绘制
09-14
在本压缩包文件中，我们重点关注如何使用OpenGL来绘制管道，特别是U型口的实现。 OpenGL提供了一个强大的图形管线（Pipeline），它将复杂的图形处理分为多个阶段，包括顶点处理、几何变换、光栅化和像素操作等。在...
Android平台 OpenGL ES3.0绘制点、线、三角形实现源码
12-10
Android平台，OpenGL ES3.0 点、线、三角形绘制方式源码实现举例。 相关绘制方式文章讲解请参考： https://xiaxl.blog.csdn.net/article/details/8873002
计算机图形学-使用Python的OpenGL库绘制一个旋转的立方体
01-06
计算机图形学
基于C++OpenGL实现的小桌茶壶图形绘制.zip
06-13
在模型变换实验的基础上，通过实现下述实验内容，掌握OpenGL中三维观察、透视投影、正交投影的参数设置，并能使用键盘移动观察相机，在透视投影和正交投影间切换，验证课程中三维观察的内容；进一步加深对OpenGL三维...
TRUNC和ROUND函数
iteye_8685的博客
05-17 186
TRUNC(for number)         TRUNC函数返回处理后的数值，其工作机制与ROUND函数极为类似，只是该函数不对指定小数前或后的部分做相应舍入选择处理，而统统截去。         其具体的语法格式如下         TRUNC（number[,decimals]）         其中：         number        待做截取处理的数值         de...
计算机图形学（第四版）（5-8章）
一直走，不要回头
05-31 736
第五章 图元属性 颜色和灰度 RGB颜色分量 灰度 opengl的颜色函数 glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); 其他基本概念，略 第六章 实现图元及属性的算法 画线算法 直线方程 DDA算法 #include <stdlib.h> #include <math.h> inline int...
GLSL内置函数（便于查找）
fztfztfzt的专栏
04-21 5714
float radians (float degrees) vec2 radians (vec2 degrees) vec3 radians (vec3 degrees) vec4 radians (vec4 degrees) 将degrees转换为弧度并返回结果，result=PI/180*degrees     将radians转换为角度并返回结果，result=180/
一文掌握OpenGL的shader内置函数
徐福记456
10-24 4761
OpenGL ES有大量的GLSL内置函数，包括：三角函数、指数函数、通用函数、浮点函数、几何函数、矩阵函数、矢量关系函数、纹理函数、原子函数、图像函数、插值函数、着色器函数等。
OpenGL学习笔记5：着色器
键盘春秋的博客
07-09 1万+
初识着色器语言变量和数据类型可用的数据类型只有4种：有符号整数，无符号整数，浮点数，布尔值。 OpenGL着色语言中没有指针和字符串或字符。返回值可以为void。向量类型所有4种基本数据类型都可以存储在二维、三维或者四维向量中： OpenGL着色语言向量数据类型 类型 描述 vec2,vec3,vec4 2分量、3分量和4分量浮点向量 ivec2,ivec3,ivec4 2
Oracle 的 Round函数
热门推荐
踏雁寻花
07-06 13万+
Round函数用法： 截取数字  格式如下：ROUND（number[,decimals]） 其中：number 待做截取处理的数值 decimals 指明需保留小数点后面的位数。可选项，忽略它则截去所有的小数部分，并四舍五入。如果为负数则表示从小数点开始左边的位数，相应整数数字用0填充，小数被去掉。需要注意的是，和trunc函数不同，对截取的数字要四舍五入。 举例如下: Sq
关于round函数
.....oioi的专栏
04-06 987
round函数可能是自定义的四舍五入函数，以实现四舍五入的功能。例如：ROUND（4.5）=5，ROUND（4.4）=4。在QBASIC中，可以用INT函数来直接实现四舍五入，INT函数的格式是INT（X），它可以实现取整的功能，例如INT（4.4）=4，INT（4.8）=4。在将它稍稍变化后，可实现四舍五入，格式为：INT（X+0.5），例如：将4.4四舍五入，INT（4.4+0.5）=4，将4
用round 函数 实现 四舍五入
蓝色梦想
12-02 3122
详细设计担当人员 要求使用round 函数来实现 四舍五入， 因为直接通过普通计算 很容易 就能实现 四舍五入，所以最后没有用round 函数， 以下是  round函数 的用法 CALL FUNCTION ROUND  EXPORTING   DECIMALS            = 0           ”保留到小数点 后几
opengl绘制旋转茶壶
最新发布
09-11
绘制旋转茶壶是OpenGL中的一个经典示例，它演示了如何使用OpenGL进行基本的3D图形绘制和变换。在OpenGL中绘制一个旋转的茶壶通常需要以下几个步骤： 1. 初始化OpenGL环境：设置视口大小、背景颜色、投影模式等。 2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值