C#下雪程序剖析

画到屏幕上 有2种方法

第一种:

把窗体大小设为屏幕大小 然后截取一张屏幕的图放在窗体上然后在这张图上绘图

第二种:

获取桌面的句柄然后获取桌面的HDC来绘图 比较麻烦

要防止一闪一闪可以用双缓存即先绘制到一张等大小的bmp然后再把bmp绘制到panel上

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

/*

* 清除屏幕的shell 命令/控制台命令,还有一些依赖平台的实现

* 如果定义了 __GNUC__ 就假定是 使用gcc 编译器,为Linux平台

*    否则 认为是 Window 平台

*/

#if defined(__GNUC__)

//下面是依赖 Linux 实现

#include <unistd.h>

#define sleep_ms(m) \

        usleep(m * 1000)

//向上移动光标函数 Linux

static void __curup(int height)

{

    int i = -1

    while (++i<height)

        printf("\033[1A") //先回到上一行  

}

#else 

// 创建等待函数 1s 60 帧 相当于 16.7ms => 1帧, 我们取16ms

// 咱么的这屏幕 推荐 1s 25帧吧 40ms

// 这里创建等待函数 以毫秒为单位 , 需要依赖 *** 作系统实现

#include <Windows.h>

#define sleep_ms(m) \

        Sleep(m)

//向上移动光标

static void __curup(int height)

{

    COORD cr = {0,0}

    // GetStdHandle(STD_OUTPUT_HANDLE) 获取屏幕对象， 设置光标

    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), cr)

}

#endif /*__GNUC__ 跨平台的代码都很丑陋 */

// 定义初始屏幕的宽高像素宏

#define _INT_WIDTH        (100)

#define _INT_HEIGHT        (50)

// 屏幕刷新帧的速率

#define _INT_FRATE        (40)

// 雪花飘落的速率,相对于 屏幕刷新帧 的倍数

#define _INT_VSNOW        (10)

/*

* 错误处理宏,msg必须是""括起来的字符串常量

* __FILE__        : 文件全路径

* __func__        : 函数名

* __LINE__        : 行数行

* __VA_ARGS__    : 可变参数宏,

* ##表示直接连接, 例如 a##b <=> ab

*/

#define cerr(msg,...) \

    fprintf(stderr, "[%s:%s:%d]" msg "\n",__FILE__,__func__,__LINE__,##__VA_ARGS__)

/*

*  屏幕结构体, 具有 宽高

*  frate  : 绘制一帧的周期, 单位是 毫秒

*  width  : 屏幕的宽,基于窗口的左上角(0,0)

*  height : 屏幕的高

*  pix    : 用一维模拟二维 主要结构如下

*             0 0 0 1 0 0 1 0 1 0

*             0 1 0 1 0 1 0 1 2 0

*             . . .

*             => 0表示没像素, 1表示1个像素,2表示2个像素....

*/

struct screen {

    int frate // 也可以用 unsigned 结构

    int width

    int height

    char *pix

}

/*

* 创建一个 屏幕结构指针 返回

*

* int frate    : 绘制一帧的周期

* int width    : 屏幕宽度

* int height    : 屏幕高度

* return        : 指向屏幕结构的指针

* */

struct screen* screen_create(int frate, int width, int height)

/*

* 销毁一个 屏幕结构指针, 并为其置空

* struct screen** : 指向 屏幕结构指针的指针, 二级销毁一级的

* */

void screen_destory(struct screen** pscr)

/**

* 屏幕绘制函数,主要生成一个雪花效果

*

* struct screen* : 屏幕数据

* return          : 0表示可以绘制了,1表示图案不变

*/

int screen_draw_snow(struct screen* scr)

/**

* 屏幕绘制动画效果, 绘制雪花动画

*

* struct screen* : 屏幕结构指针

*/

void screen_flash_snow(struct screen* scr)

// 主函数,主业务在此运行

int main(int argc, char *argv[])

{

    struct screen* scr = NULL

    //创建一个屏幕对象

    scr = screen_create(_INT_FRATE, _INT_WIDTH, _INT_HEIGHT)

    if (NULL == scr)

        exit(EXIT_FAILURE)

    //绘制雪花动画

    screen_flash_snow(scr)

    //销毁这个屏幕对象

    screen_destory(&scr)

    return 0

}

/*

* 创建一个 屏幕结构指针 返回

*

* int frate    : 绘制一帧的周期

* int width    : 屏幕宽度

* int height    : 屏幕高度

* return        : 指向屏幕结构的指针

* */

struct screen*

    screen_create(int frate, int width, int height)

{

    struct screen *scr = NULL

    if (frate<0 || width <= 0 || height <= 0) {

        cerr("[WARNING]check is frate<0 || width<=0 || height<=0 err!")

        return NULL

    }

    //后面是 为 scr->pix 分配的内存 width*height

    scr = malloc(sizeof(struct screen) + sizeof(char)*width*height)

    if (NULL == scr) {

        cerr("[FATALG]Out of memory!")

        return NULL

    }

    scr->frate = frate

    scr->width = width

    scr->height = height

    //减少malloc次数,malloc消耗很大,内存泄露呀,内存碎片呀

    scr->pix = ((char *)scr) + sizeof(struct screen)

    return scr

}

/*

* 销毁一个 屏幕结构指针, 并为其置空

* struct screen** : 指向 屏幕结构指针的指针, 二级销毁一级的

* */

void

screen_destory(struct screen** pscr)

{

    if (NULL == pscr || NULL == *pscr)

        return

    free(*pscr)

    // 避免野指针

    *pscr = NULL

}

//构建开头 的雪花,下面宏表示每 _INT_SHEAD 个步长,一个雪花,需要是2的幂

//static 可以理解为 private, 宏,位 *** 作代码多了确实难读

#define _INT_SHEAD (1<<2)

static void __snow_head(char* snow, int len)

{

    int r = 0

    //数据需要清空

    memset(snow, 0, len)

    for () {

        //取余一个技巧 2^3 - 1 = 7 => 111 , 并就是取余数

        int t = rand() & (_INT_SHEAD - 1)

        if (r + t >= len)

            break

        snow[r + t] = 1

        r += _INT_SHEAD

    }

}

#undef _INT_SHEAD

//通过 上一个 scr->pix[scr->width*(idx-1)] => scr->pix[scr->width*idx]

//下面的宏 规定 雪花左右摇摆 0 向左一个像素, 1 表示 不变, 2表示向右一个像素

#define _INT_SWING (3)

static void __snow_next(struct screen* scr, int idx)

{

    int width = scr->width

    char* psnow = scr->pix + width*(idx - 1)

    char* snow = psnow + width

    int i, j, t // i索引, j保存下一个瞬间雪花的位置,t 临时补得,解决雪花重叠问题

                 //为当前行重置

    memset(snow, 0, width)

    //通过上一次雪花位置 计算下一次雪花位置

    for (i = 0 i<width ++i) {

        for (t = psnow[i] t>0 --t) { // 雪花可以重叠

                                       // rand()%_INT_SWING - 1 表示 雪花 横轴的偏移量,相对上一次位置

            j = i + rand() % _INT_SWING - 1

            j = j<0 ? width - 1 : j >= width ? 0 : j // j如果越界了,左边越界让它到右边,右边越界到左边

            ++snow[j]

        }

    }

}

/**

* 屏幕绘制函数,主要生成一个雪花效果

*

* struct screen* : 屏幕数据

* return          : 0表示可以绘制了,1表示图案不变

*/

int

screen_draw_snow(struct screen* scr)

{

    // 静态变量,默认初始化为0,每次都共用

    static int __speed = 0

    int idx

    if (++__speed != _INT_VSNOW)

        return 1

    //下面 就是 到了雪花飘落的时刻了 既 __speed == _INT_VSNOW

    __speed = 0

    //这里重新构建雪花界面,先构建头部,再从尾部开始构建

    for (idx = scr->height - 1 idx > 0 --idx)

        __snow_next(scr, idx)

    //构建头部

    __snow_head(scr->pix, scr->width)

    return 0

}

//buf 保存scr 中pix 数据,构建后为 (width+1)*height, 后面宏是雪花图案

#define _CHAR_SNOW ‘*‘

static void __flash_snow_buffer(struct screen* scr, char* buf)

{

    int i, j, rt

    int height = scr->height, width = scr->width

    int frate = scr->frate //刷新的帧频率    

                            //每次都等一下

    for (sleep_ms(frate)) {

        //开始绘制屏幕

        rt = screen_draw_snow(scr)

        if (rt)

            continue

        for (i = 0i<height ++i) {

            char* snow = scr->pix + i*width

            for (j = 0 j<width ++j)

                buf[rt++] = snow[j] ? _CHAR_SNOW : ‘ ‘

            buf[rt++] = ‘\n‘

        }

        buf[rt - 1] = ‘\0‘

        //正式绘制到屏幕上

        puts(buf)

        //清空老屏幕,屏幕光标回到最上面

        __curup(height)

    }

}

#undef _CHAR_SNOW

/**

* 屏幕绘制动画效果, 绘制雪花动画

*

* struct screen* : 屏幕结构指针

*/

void

screen_flash_snow(struct screen* scr)

{

    char* buf = NULL

    // 初始化随机数种子,改变雪花轨迹

    srand((unsigned)time(NULL))

    buf = malloc(sizeof(char)*(scr->width + 1)*scr->height)

    if (NULL == buf) {

        cerr("[FATAL]Out of memory!")

        exit(EXIT_FAILURE)

    }

    __flash_snow_buffer(scr, buf)

    //1.这里理论上不会执行到这,没加控制器. 2.对于buf=NULL,这种代码 可以省掉,看编程习惯

    free(buf)

    buf = NULL

}

1. Adobe Photoshop：Adobe Photoshop可以制作出让英文字母有雪花特效的图片。它有一系列的画笔、滤镜和工具可以帮助你设计出令人惊叹的图片。

2. CorelDRAW：CorelDRAW是一款专业的图像处理和编辑软件，可以让你制作出有雪花效果的英文字母。它有各种滤镜和工具来让你实现你的想法。

3. Adobe Illustrator：Adobe Illustrator是一款非常有用的图像处理软件，可以让你快速制作出英文字母有雪花效果的图片。它有许多实用的工具，可以让你制作出令人惊叹的图片。

4. GIMP：GIMP是一款免费的图像处理软件，可以为你制作出有雪花特效的英文字母。它拥有丰富的画笔、滤镜和工具，可以帮助你实现你的想法。

5. Inkscape：Inkscape是一款免费的矢量图像处理软件，可以让你制作出有雪花效果的英文字母。它有许多专业的特性，可以为你制作出令人惊叹的图片。

---