void draw_fresh(char (*p)[32])
{
int i, j;
for(i = 0; i < 24; i++) {
for(j = 0; j < 32; j++) {
if(p[i][j]) {
draw_element(j, i, COLOR);
}else {
draw_element(j, i, BLACK);
}
}
}
}
void SoftwareRendererImp::draw_group( Group& group ) {
for ( size_t i = 0; i < group.elements.size(); ++i ) {
draw_element(group.elements[i]);
}
}
void
hid_expose_callback (HID * hid, BoxType * region, void *item)
{
HID *old_gui = gui;
gui = hid;
Output.fgGC = gui->graphics->make_gc ();
Output.bgGC = gui->graphics->make_gc ();
Output.pmGC = gui->graphics->make_gc ();
hid->graphics->set_color (Output.pmGC, "erase");
hid->graphics->set_color (Output.bgGC, "drill");
if (item)
{
doing_pinout = true;
draw_element ((ElementType *)item);
doing_pinout = false;
}
else
DrawEverything (region);
gui->graphics->destroy_gc (Output.fgGC);
gui->graphics->destroy_gc (Output.bgGC);
gui->graphics->destroy_gc (Output.pmGC);
gui = old_gui;
}
void SoftwareRendererImp::draw_svg(SVG& svg) {
// set top level transformation
transformation = canvas_to_screen;
// draw all elements
for (size_t i = 0; i < svg.elements.size(); ++i) {
draw_element(svg.elements[i]);
}
// draw canvas outline
Vector2D a = transform(Vector2D(0, 0));
a.x--;
a.y++;
Vector2D b = transform(Vector2D(svg.width, 0));
b.x++;
b.y++;
Vector2D c = transform(Vector2D(0, svg.height));
c.x--;
c.y--;
Vector2D d = transform(Vector2D(svg.width, svg.height));
d.x++;
d.y--;
rasterize_line(a.x, a.y, b.x, b.y, Color::Black);
rasterize_line(a.x, a.y, c.x, c.y, Color::Black);
rasterize_line(d.x, d.y, b.x, b.y, Color::Black);
rasterize_line(d.x, d.y, c.x, c.y, Color::Black);
// resolve and send to render target
resolve();
}
void SoftwareRendererImp::draw_svg( SVG& svg ) {
// set top level transformation
transformation = canvas_to_screen;
//allocate array for new target
size_t super_w, super_h, super_size;
super_w = this->target_w * sample_rate;
super_h = this->target_h * sample_rate;
unsigned char* old_buf = this->render_target;
unsigned char* super_buf = new unsigned char [super_w * super_h * 4];
set_render_target( super_buf, super_w, super_h );
clear_target();
/*
printf("before rendering:\n");
for (size_t i = 0; i < super_w * super_h; i++ ) {
if (super_buf[i] != 255) {
printf("super_buf[%zu] = %u\n", i, super_buf[i]);
}
}
*/
// draw all elements
for ( size_t i = 0; i < svg.elements.size(); ++i ) {
transformation = canvas_to_screen;
draw_element(svg.elements[i]);
}
// draw canvas outline
Vector2D a = transform(Vector2D( 0 , 0 )); a.x--; a.y++;
Vector2D b = transform(Vector2D(svg.width, 0 )); b.x++; b.y++;
Vector2D c = transform(Vector2D( 0 ,svg.height)); c.x--; c.y--;
Vector2D d = transform(Vector2D(svg.width,svg.height)); d.x++; d.y--;
rasterize_line(a.x, a.y, b.x, b.y, Color::Black);
rasterize_line(a.x, a.y, c.x, c.y, Color::Black);
rasterize_line(d.x, d.y, b.x, b.y, Color::Black);
rasterize_line(d.x, d.y, c.x, c.y, Color::Black);
this->sample_buffer = super_buf;
/*
printf("after rendering:\n");
for (size_t i = 0; i < super_w * super_h; i++ ) {
if (super_buf[i] != 255) {
printf("super_buf[%zu] = %u\n", i, super_buf[i]);
}
}
*/
set_render_target( old_buf, super_w / sample_rate, super_h / sample_rate);
clear_target();
// resolve and send to render target
resolve();
}
void reset_block()
{
int i,j;
int x,y;
for (i = 0; i < ROW_CANVAS; i++) {
for (j = 0; j < COL_CANVAS; j++) {
if ( block_entry_p->arr[i][j] == 1 ) {
block_entry_p->arr[i][j] = 0;
x = j * DRAW_BLOCK_SIZE;
y = i * DRAW_BLOCK_SIZE;
draw_element(x+autodown_x, y+autodown_y, PINK);
}
}
}
}
static void load_laby(int num){
int x,y;
for(x=0;x<RING_WIDTH;x++)
for(y=0;y<RING_HEIGHT;y++){
ring[x][y] = labyrinth[num][y][x];
if(ring[x][y] != ' '){
draw_element(x,y,wall,0);
}else{
draw_filled_rect(x * SNAKE_ELEMENT_SIZE,
y * SNAKE_ELEMENT_SIZE,
x * SNAKE_ELEMENT_SIZE+SNAKE_ELEMENT_SIZE-1,
y * SNAKE_ELEMENT_SIZE+SNAKE_ELEMENT_SIZE-1, MAKE_COLOR(COLOR_WHITE,COLOR_WHITE));
}
}
}
static void snake_generate_apple()
{
int x,y,i;
while(1)
{
randomagain:
x = rand() % RING_WIDTH;
y = rand() % RING_HEIGHT;
if(ring[x][y] != ' ') continue;
i = snake_tail;
while(1){
if(snake[i][0] == x && snake[i][1] == y) goto randomagain;
if(i == snake_head) break;
i = (i+1)%SNAKE_MAX_LENGTH;
}
draw_element(x,y,apple,0);
ring[x][y] = 1;
break;
}
}
void init()
{
int i,j;
int x,y;
int is_init = 0;
russian_p = calloc(COL*ROW, sizeof(int));
for (i = 0; i < ROW; i++) {//20
for (j = 0; j < COL; j++) {//10
x=j*DRAW_BLOCK_SIZE;
y=i*DRAW_BLOCK_SIZE;
if (is_init == 0) {
max_x = min_x = x;
max_y = min_y = y;
is_init = 1;
}else{
if (x > max_x) {
max_x = x;
}
if (x < min_x) {
min_x = x;
}
if (y > max_y) {
max_y = y;
}
if (y < min_y) {
min_y = y;
}
}
draw_element(x, y, 0xfa);
//sleep(1);
}
}
//printf("max_x %d min_x %d max_y %d min_y %d\n", max_x, min_x, max_y, min_y);
}
void draw_picture(int row_canvas, int color, int is_draw){
int i,j;
int x,y;
int max_x_i, max_x_j, min_x_i, min_x_j, max_y_i, max_y_j;
switch(block_entry_p->type){
case F**K:
switch(block_entry_p->pos){
case UP:
block_entry_p->arr[0][1] = 1;
block_entry_p->arr[1][0] = 1;
block_entry_p->arr[1][1] = 1;
block_entry_p->arr[1][2] = 1;
min_x_i = 1; min_x_j = 0;
max_x_i = 1; max_x_j = 2;
max_y_i = 1; max_y_j = 2;
break;
case DOWN:
block_entry_p->arr[0][0] = 1;
block_entry_p->arr[0][1] = 1;
block_entry_p->arr[0][2] = 1;
block_entry_p->arr[1][1] = 1;
min_x_i = 0; min_x_j = 0;
max_x_i = 0; max_x_j = 2;
max_y_i = 1; max_y_j = 1;
break;
case LEFT:
block_entry_p->arr[1][0] = 1;
block_entry_p->arr[0][1] = 1;
block_entry_p->arr[1][1] = 1;
block_entry_p->arr[2][1] = 1;
min_x_i = 1; min_x_j = 0;
max_x_i = 0; max_x_j = 1;
max_y_i = 2; max_y_j = 1;
break;
case RIGHT:
block_entry_p->arr[0][1] = 1;
block_entry_p->arr[1][1] = 1;
block_entry_p->arr[1][2] = 1;
block_entry_p->arr[2][1] = 1;
min_x_i = 0; min_x_j = 1;
max_x_i = 1; max_x_j = 2;
max_y_i = 2; max_y_j = 1;
break;
default:
break;
}
break;
default:break;
}
for (i = 0; i < row_canvas; i++) {
for (j = 0; j < COL_CANVAS; j++) {
if ( block_entry_p->arr[i][j] == 1 ) {
x = j*DRAW_BLOCK_SIZE;
y = i*DRAW_BLOCK_SIZE;
if(max_x_i == i && max_x_j == j){
current_max_x = x;
}
if(min_x_i == i && min_x_j == j){
current_min_x = x;
}
if(max_y_i == i && max_y_j == j){
current_max_y =y;
}
if (is_draw == IS_DRAW) {
draw_element(x+autodown_x, y+autodown_y, color);
//sleep(1);
}
}
}
}
//printf(" current_max_x %d current_max_y %d current_min_x %d \n", current_max_x, current_max_y, current_min_x);
}
void copy(){
int k;
int i, j ,l, m, x, y, z , p, q;
int is_game_over = 0;
//set top level i j for copy gamever
top_i_j tmp;
top_i_j i_j_arr[COL];
for (k = 0; k < COL; k++) {
tmp.i = 0;
tmp.j = k;
i_j_arr[k] =tmp;
}
for (i = 0; i < ROW; i++) {
for (j = 0; j < COL; j++) {
x=j*DRAW_BLOCK_SIZE;
y=i*DRAW_BLOCK_SIZE;
for (l = 0; l < ROW_CANVAS; l++) {
for (m = 0; m < COL_CANVAS; m++) {
p=m*DRAW_BLOCK_SIZE+autodown_x;
q=l*DRAW_BLOCK_SIZE+autodown_y;
if(x == p && y ==q){
if(block_entry_p->arr[l][m]==1){
//printf("wwwwwwwwwwwwwwwwwwwwwwww i %d j %d\n", i, j);
russian_p[i][j]=1;
draw_element(p, q, YELLOW);
for (k = 0; k < COL; k++) {
if (i==i_j_arr[k].i && j ==i_j_arr[k].j) {
is_game_over=1;
}
}
}
}
}
}
}
}
//delete complete block
int delete_num = 0;
int last_delete_row = 0;
for (i = ROW-1; i > 0; i--) {
for (j = 0; j < COL; j++) {
if (russian_p[i][j] == 0) {
break;
}
if (j==COL-1) {
for (k = 0; k < COL; k++) {
x=k*DRAW_BLOCK_SIZE;
y=i*DRAW_BLOCK_SIZE;
draw_element(x, y, PINK);
russian_p[i][k] = 0;
printf("delete i %d k %d\n",i,k);
}
delete_num++;
last_delete_row = i;
printf("---------------------------------\n");
sleep(2);
}
}
}
printf("delete_num %d\n", delete_num);
//after delete move down
if (delete_num) {
for (j = 0; j < COL; j++) {
for (i = last_delete_row-1; i >= 0 ; i--) {
x = j * DRAW_BLOCK_SIZE;
y = i * DRAW_BLOCK_SIZE;
z = (i+delete_num) * DRAW_BLOCK_SIZE;
if (russian_p[i][j] == 1) {
draw_element(x, y, PINK);
russian_p[i][j] = 0;
//sleep(2);
printf("z %d y %d\n",z, y);
draw_element(x, z, YELLOW);
russian_p[i+delete_num][j] = 1;
}
}
}
}
if (is_game_over) {
printf("game over!!!");
exit(1);
}
}
sk_sp<GrTexture> GrClipMaskManager::CreateAlphaClipMask(GrContext* context,
int32_t elementsGenID,
GrReducedClip::InitialState initialState,
const GrReducedClip::ElementList& elements,
const SkVector& clipToMaskOffset,
const SkIRect& clipSpaceIBounds) {
GrResourceProvider* resourceProvider = context->resourceProvider();
GrUniqueKey key;
GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
if (GrTexture* texture = resourceProvider->findAndRefTextureByUniqueKey(key)) {
return sk_sp<GrTexture>(texture);
}
// There's no texture in the cache. Let's try to allocate it then.
GrPixelConfig config = kRGBA_8888_GrPixelConfig;
if (context->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
config = kAlpha_8_GrPixelConfig;
}
sk_sp<GrDrawContext> dc(context->newDrawContext(SkBackingFit::kApprox,
clipSpaceIBounds.width(),
clipSpaceIBounds.height(),
config));
if (!dc) {
return nullptr;
}
// The texture may be larger than necessary, this rect represents the part of the texture
// we populate with a rasterization of the clip.
SkIRect maskSpaceIBounds = SkIRect::MakeWH(clipSpaceIBounds.width(), clipSpaceIBounds.height());
// The scratch texture that we are drawing into can be substantially larger than the mask. Only
// clear the part that we care about.
dc->clear(&maskSpaceIBounds,
GrReducedClip::kAllIn_InitialState == initialState ? 0xffffffff : 0x00000000,
true);
// Set the matrix so that rendered clip elements are transformed to mask space from clip
// space.
const SkMatrix translate = SkMatrix::MakeTrans(clipToMaskOffset.fX, clipToMaskOffset.fY);
// It is important that we use maskSpaceIBounds as the stencil rect in the below loop.
// The second pass that zeros the stencil buffer renders the rect maskSpaceIBounds so the first
// pass must not set values outside of this bounds or stencil values outside the rect won't be
// cleared.
// walk through each clip element and perform its set op
for (GrReducedClip::ElementList::Iter iter = elements.headIter(); iter.get(); iter.next()) {
const Element* element = iter.get();
SkRegion::Op op = element->getOp();
bool invert = element->isInverseFilled();
if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
GrFixedClip clip(maskSpaceIBounds);
// draw directly into the result with the stencil set to make the pixels affected
// by the clip shape be non-zero.
static constexpr GrUserStencilSettings kStencilInElement(
GrUserStencilSettings::StaticInit<
0xffff,
GrUserStencilTest::kAlways,
0xffff,
GrUserStencilOp::kReplace,
GrUserStencilOp::kReplace,
0xffff>()
);
if (!stencil_element(dc.get(), clip, &kStencilInElement,
translate, element)) {
return nullptr;
}
// Draw to the exterior pixels (those with a zero stencil value).
static constexpr GrUserStencilSettings kDrawOutsideElement(
GrUserStencilSettings::StaticInit<
0x0000,
GrUserStencilTest::kEqual,
0xffff,
GrUserStencilOp::kZero,
GrUserStencilOp::kZero,
0xffff>()
);
if (!dc->drawContextPriv().drawAndStencilRect(clip, &kDrawOutsideElement,
op, !invert, false,
translate,
SkRect::Make(clipSpaceIBounds))) {
return nullptr;
}
} else {
// all the remaining ops can just be directly draw into the accumulation buffer
GrPaint paint;
paint.setAntiAlias(element->isAA());
paint.setCoverageSetOpXPFactory(op, false);
draw_element(dc.get(), GrNoClip(), paint, translate, element);
}
}
sk_sp<GrTexture> texture(dc->asTexture());
SkASSERT(texture);
texture->resourcePriv().setUniqueKey(key);
return texture;
}
void gui_snake_draw() {
unsigned short new_head;
unsigned short new_tail;
unsigned short new_cord;
char game_over_flag = 0,draw_head,clear_tail,draw_points=1;
unsigned char prevdir = direction;
unsigned int i;
new_head = (snake_head+1)%SNAKE_MAX_LENGTH;
new_tail = (snake_tail+1)%SNAKE_MAX_LENGTH;
draw_head = 1;
clear_tail = 1;
if(direction == DIR_RIGHT){
new_cord = (snake[snake_head][0]+1)%RING_WIDTH;
snake[new_head][0] = new_cord;
snake[new_head][1] = snake[snake_head][1];
}
if(direction == DIR_LEFT){
new_cord = snake[snake_head][0]-1;
if(new_cord == 0xFFFF) new_cord = RING_WIDTH-1;
snake[new_head][0] = new_cord;
snake[new_head][1] = snake[snake_head][1];
}
if(direction == DIR_UP){
new_cord = snake[snake_head][1]-1;
if(new_cord == 0xFFFF) new_cord = RING_HEIGHT-1;
snake[new_head][0] = snake[snake_head][0];
snake[new_head][1] = new_cord;
}
if(direction == DIR_DOWN){
new_cord = (snake[snake_head][1]+1)%RING_HEIGHT;
snake[new_head][0] = snake[snake_head][0];
snake[new_head][1] = new_cord;
}
i = snake_tail;
while(1){
if(snake[i][0] == snake[new_head][0] && snake[i][1] == snake[new_head][1]){
game_over_flag = 1;
break;
}
if(i == snake_head) break;
i = (i+1)%SNAKE_MAX_LENGTH;
}
if(ring[snake[new_head][0]][snake[new_head][1]] == 1){
ring[snake[new_head][0]][snake[new_head][1]] = ' ';
snake_generate_apple();
points+=level;
draw_points = 1;
if((new_head+1)%SNAKE_MAX_LENGTH != snake_tail){
new_tail = snake_tail;
clear_tail = 0;
}
}else if(ring[snake[new_head][0]][snake[new_head][1]] != ' '){
game_over_flag = 1;
}
if(draw_head){
if(direction == DIR_UP) draw_element(snake[new_head][0],snake[new_head][1],head,2); //up
if(direction == DIR_LEFT) draw_element(snake[new_head][0],snake[new_head][1],head,0); //left
if(direction == DIR_DOWN) draw_element(snake[new_head][0],snake[new_head][1],head,1); //down
if(direction == DIR_RIGHT) draw_element(snake[new_head][0],snake[new_head][1],head,3); //right
new_cord = snake_head-1;
if(new_cord == 0xFFFF) new_cord = SNAKE_MAX_LENGTH-1;
if(snake[new_cord][0] > snake[new_head][0] && snake[new_cord][1] > snake[new_head][1] && direction == DIR_UP) draw_element(snake[snake_head][0],snake[snake_head][1],tail2,2);
else if(snake[new_cord][0] > snake[new_head][0] && snake[new_cord][1] > snake[new_head][1] && direction == DIR_LEFT) draw_element(snake[snake_head][0],snake[snake_head][1],tail2,0);
else if(snake[new_cord][0] < snake[new_head][0] && snake[new_cord][1] > snake[new_head][1] && direction == DIR_UP) draw_element(snake[snake_head][0],snake[snake_head][1],tail2,4);
else if(snake[new_cord][0] < snake[new_head][0] && snake[new_cord][1] > snake[new_head][1] && direction == DIR_RIGHT) draw_element(snake[snake_head][0],snake[snake_head][1],tail2,3);
else if(snake[new_cord][0] < snake[new_head][0] && snake[new_cord][1] < snake[new_head][1] && direction == DIR_RIGHT) draw_element(snake[snake_head][0],snake[snake_head][1],tail2,2);
else if(snake[new_cord][0] < snake[new_head][0] && snake[new_cord][1] < snake[new_head][1] && direction == DIR_DOWN) draw_element(snake[snake_head][0],snake[snake_head][1],tail2,0);
else if(snake[new_cord][0] > snake[new_head][0] && snake[new_cord][1] < snake[new_head][1] && direction == DIR_LEFT) draw_element(snake[snake_head][0],snake[snake_head][1],tail2,4);
else if(snake[new_cord][0] > snake[new_head][0] && snake[new_cord][1] < snake[new_head][1] && direction == DIR_DOWN) draw_element(snake[snake_head][0],snake[snake_head][1],tail2,3);
else if(prevdir == direction && (direction == DIR_RIGHT || direction == DIR_LEFT)) draw_element(snake[snake_head][0],snake[snake_head][1],tail,0);
else if(prevdir == direction && (direction == DIR_UP || direction == DIR_DOWN)) draw_element(snake[snake_head][0],snake[snake_head][1],tail,1);
}
prevdir = direction;
if(clear_tail){
draw_filled_rect(snake[snake_tail][0] * SNAKE_ELEMENT_SIZE,
snake[snake_tail][1] * SNAKE_ELEMENT_SIZE,
snake[snake_tail][0] * SNAKE_ELEMENT_SIZE+SNAKE_ELEMENT_SIZE-1,
snake[snake_tail][1] * SNAKE_ELEMENT_SIZE+SNAKE_ELEMENT_SIZE-1, COLOR_WHITE);
}
snake_head = new_head;
snake_tail = new_tail;
msleep(100);
if(game_over_flag){
game_over();
game_over_flag = 0;
}
if(draw_points){
draw_points = 0;
sprintf(str_buf,"Points: %d",points);
draw_string(10,220,str_buf, MAKE_COLOR(COLOR_WHITE, COLOR_BLUE));
}
}
