Example #1
0
static void
poly_aabb(int n, const int32_t * point, struct srt *srt, struct matrix *ts, int aabb[4]) {
	struct matrix mat;
	if (ts == NULL) {
		matrix_identity(&mat);
	} else {
		mat = *ts;
	}
	matrix_srt(&mat, srt);
	int *m = mat.m;

	int i;
	for (i=0;i<n;i++) {
		int x = point[i*2];
		int y = point[i*2+1];

		int xx = (x * m[0] + y * m[2]) / 1024 + m[4];
		int yy = (x * m[1] + y * m[3]) / 1024 + m[5];

		if (xx < aabb[0])
			aabb[0] = xx;
		if (xx > aabb[2])
			aabb[2] = xx;
		if (yy < aabb[1])
			aabb[1] = yy;
		if (yy > aabb[3])
			aabb[3] = yy;
	}
}
Example #2
0
void
sprite_drawquad(struct pack_picture *picture, const struct srt *srt,  const struct sprite_trans *arg) {
	struct matrix tmp;
	struct vertex_pack vb[4];
	int i,j;
	if (arg->mat == NULL) {
		matrix_identity(&tmp);
	} else {
		tmp = *arg->mat;
	}
	matrix_srt(&tmp, srt);
	int *m = tmp.m;
	for (i=0;i<picture->n;i++) {
		struct pack_quad *q = &picture->rect[i];
		int glid = texture_glid(q->texid);
		if (glid == 0)
			continue;
		shader_texture(glid, 0);
		for (j=0;j<4;j++) {
			int xx = q->screen_coord[j*2+0];
			int yy = q->screen_coord[j*2+1];
			float vx = (xx * m[0] + yy * m[2]) / 1024 + m[4];
			float vy = (xx * m[1] + yy * m[3]) / 1024 + m[5];
			float tx = q->texture_coord[j*2+0];
			float ty = q->texture_coord[j*2+1];

			screen_trans(&vx,&vy);
			vb[j].vx = vx;
			vb[j].vy = vy;
			vb[j].tx = tx;
			vb[j].ty = ty;
		}
		shader_draw(vb, arg->color, arg->additive);
	}
}
Example #3
0
static void
anchor_update(struct sprite *s, struct srt *srt, struct sprite_trans *arg) {
	struct matrix *r = s->s.mat;
	if (arg->mat == NULL) {
		matrix_identity(r);
	} else {
		*r = *arg->mat;
	}
	matrix_srt(r, srt);
}
Example #4
0
static int
child_pos(struct sprite *s, struct srt *srt, struct sprite_trans *ts, struct sprite *t, int pos[2]) {
	struct sprite_trans temp;
	struct matrix temp_matrix;
	struct sprite_trans *st = trans_mul(&s->t, ts, &temp, &temp_matrix);
	if (s == t) {
		struct matrix tmp;
		if (st->mat == NULL) {
			matrix_identity(&tmp);
		} else {
			tmp = *st->mat;
		}
		matrix_srt(&tmp, srt);
		switch (s->type) {
		case TYPE_PICTURE:
			picture_pos(tmp.m, s->s.pic, srt, st, pos);
			return 0;
		case TYPE_LABEL:
			label_pos(tmp.m, s->s.label, srt, st, pos);
			return 0;
		case TYPE_ANIMATION:
		case TYPE_PANNEL:
			pos[0] = tmp.m[4] / SCREEN_SCALE;
			pos[1] = tmp.m[5] / SCREEN_SCALE;
			return 0;
		default:
			return 1;
		}
	} 
	
	if (s->type != TYPE_ANIMATION){
		return 1;
	}

	struct pack_animation *ani = s->s.ani;
	int frame = real_frame(s) + s->start_frame;
	struct pack_frame * pf = &ani->frame[frame];
	int i;
	for (i=0;i<pf->n;i++) {
		struct pack_part *pp = &pf->part[i];
		int index = pp->component_id;
		struct sprite * child = s->data.children[index];
		if (child == NULL) {
			continue;
		}
		struct sprite_trans temp2;
		struct matrix temp_matrix2;
		struct sprite_trans *ct = trans_mul(&pp->t, st, &temp2, &temp_matrix2);
		if (child_pos(child, srt, ct, t, pos) == 0) {
			return 0;
		}
	}
	return 1;
}
Example #5
0
void
calc_particle_system_mat(struct particle * p, struct matrix *m, int edge) {
	matrix_identity(m);
	struct srt srt;
	srt.rot = p->rotation * 1024 / 360;
	srt.scalex = p->size * 1024 / edge;
	srt.scaley = srt.scalex;
	srt.offx = (p->pos.x + p->startPos.x) * SCREEN_SCALE;
	srt.offy = (p->pos.y + p->startPos.y) * SCREEN_SCALE;
	matrix_srt(m, &srt);

	matrix_mul(m, m, &p->emitMatrix);
}
Example #6
0
void calc_particle_system_mat(struct particle * p, struct matrix *m, int edge) {
	struct srt srt;
	struct matrix tmp;

	matrix_identity(m);
	srt.rot = (int)(p->rotation * 1024 / 360);
	srt.scalex = (int)(p->size * 1024 / edge);
	srt.scaley = srt.scalex;
	srt.offx = (int)((p->pos.x + p->startPos.x) * SCREEN_SCALE);
	srt.offy = (int)((p->pos.y + p->startPos.y) * SCREEN_SCALE);
	matrix_srt(m, &srt);
	memcpy(tmp.m, m, sizeof(int) * 6);
	matrix_mul(m, &tmp, &p->emitMatrix);
}
Example #7
0
void
sprite_drawquad(struct pack_picture *picture, struct pack_picture *mask, const struct srt *srt,  const struct sprite_trans *arg) {
	struct matrix tmp;
	float vb[16];
	int i,j;
	if (arg->mat == NULL) {
		matrix_identity(&tmp);
	} else {
		tmp = *arg->mat;
	}
	matrix_srt(&tmp, srt);
	int *m = tmp.m;
	for (i=0;i<picture->n;i++) {
		struct pack_quad *q = &picture->rect[i];
		int glid = texture_glid(q->texid);
		if (glid == 0)
			continue;
		shader_texture(glid);
		for (j=0;j<4;j++) {
			int xx = q->screen_coord[j*2+0];
			int yy = q->screen_coord[j*2+1];
			float vx = (xx * m[0] + yy * m[2]) / 1024 + m[4];
			float vy = (xx * m[1] + yy * m[3]) / 1024 + m[5];
			float tx = q->texture_coord[j*2+0];
			float ty = q->texture_coord[j*2+1];

			screen_trans(&vx,&vy);
			texture_coord(q->texid, &tx, &ty);
			vb[j*4+0] = vx;
			vb[j*4+1] = vy;
			vb[j*4+2] = tx;
			vb[j*4+3] = ty;
		}
		if(!enable_visible_test || !screen_is_poly_invisible(vb,4,4))
		{
            if (mask != NULL) {
                float tx = mask->rect[0].texture_coord[0];
                float ty = mask->rect[0].texture_coord[1];
                texture_coord(mask->rect[0].texid, &tx, &ty);
                float delta_tx = tx - vb[2];
                float delta_ty = ty - vb[3];
                shader_mask(delta_tx, delta_ty);
            }
			shader_draw(vb, arg->color);
        }
	}
}
Example #8
0
void
sprite_drawpolygon(struct pack_polygon *poly, const struct srt *srt, const struct sprite_trans *arg) {
	struct matrix tmp;
	int i,j;
	if (arg->mat == NULL) {
		matrix_identity(&tmp);
	} else {
		tmp = *arg->mat;
	}
	matrix_srt(&tmp, srt);
	int *m = tmp.m;
	for (i=0;i<poly->n;i++) {
		struct pack_poly *p = &poly->poly[i];
		int glid = texture_glid(p->texid);
		if (glid == 0)
			continue;
		shader_texture(glid);
		int pn = p->n;

		ARRAY(float, vb, 4 * pn);

		for (j=0;j<pn;j++) {
			int xx = p->screen_coord[j*2+0];
			int yy = p->screen_coord[j*2+1];
		
			
			float vx = (xx * m[0] + yy * m[2]) / 1024 + m[4];
			float vy = (xx * m[1] + yy * m[3]) / 1024 + m[5];
			float tx = p->texture_coord[j*2+0];
			float ty = p->texture_coord[j*2+1];

			screen_trans(&vx,&vy);
	
			texture_coord(p->texid, &tx, &ty);
			vb[j*4+0] = vx;
			vb[j*4+1] = vy;
			vb[j*4+2] = tx;
			vb[j*4+3] = ty;
		}
		shader_drawpolygon(pn, vb, arg->color);
	}
}
Example #9
0
static int
draw_utf8(int unicode, int cx, int cy, int size, const struct srt *srt,
	uint32_t color, const struct sprite_trans *arg) {
	const struct dfont_rect * rect = dfont_lookup(Dfont, unicode, FONT_SIZE);
	if (rect == NULL) {
		return 0;
	}
	struct matrix tmp;
	struct matrix mat1 = {{ 1024,0,0,1024, cx* SCREEN_SCALE, cy*SCREEN_SCALE }};
	struct matrix *m;

	if (arg->mat) {
		m=&tmp;
		matrix_mul(m, &mat1, arg->mat);
	} else {
		m=&mat1;
	}
	matrix_srt(m, srt);
	draw_rect(rect,size,m,color);

	return (rect->w-1) * size / FONT_SIZE ;
}
Example #10
0
int
sprite_pos(struct sprite *s, struct srt *srt, struct matrix *m, int pos[2]) {
	struct matrix temp;
	struct matrix *t = mat_mul(s->t.mat, m, &temp);
	matrix_srt(t, srt);
	switch (s->type) {
	case TYPE_PICTURE:
		picture_pos(t->m, s->s.pic, pos);
		return 0;
	case TYPE_LABEL:
		label_pos(t->m, s->s.label, pos);
		return 0;
	case TYPE_ANIMATION:
	case TYPE_PANNEL:
		pos[0] = t->m[4] / SCREEN_SCALE;
		pos[1] = t->m[5] / SCREEN_SCALE;
		return 0;
	default:
		return 1;
	}

}
Example #11
0
static void
set_scissor(const struct pack_pannel *p, const struct srt *srt, const struct sprite_trans *arg) {
	struct matrix tmp;
	if (arg->mat == NULL) {
		matrix_identity(&tmp);
	} else {
		tmp = *arg->mat;
	}
	matrix_srt(&tmp, srt);
	int *m = tmp.m;
	int x[4] = { 0, p->width * SCREEN_SCALE, p->width * SCREEN_SCALE, 0 };
	int y[4] = { 0, 0, p->height * SCREEN_SCALE, p->height * SCREEN_SCALE };
	int minx = (x[0] * m[0] + y[0] * m[2]) / 1024 + m[4];
	int miny = (x[0] * m[1] + y[0] * m[3]) / 1024 + m[5];
	int maxx = minx;
	int maxy = miny;
	int i;
	for (i=1;i<4;i++) {
		int vx = (x[i] * m[0] + y[i] * m[2]) / 1024 + m[4];
		int vy = (x[i] * m[1] + y[i] * m[3]) / 1024 + m[5];
		if (vx<minx) {
			minx = vx;
		} else if (vx > maxx) {
			maxx = vx;
		}
		if (vy<miny) {
			miny = vy;
		} else if (vy > maxy) {
			maxy = vy;
		}
	}
	minx /= SCREEN_SCALE;
	miny /= SCREEN_SCALE;
	maxx /= SCREEN_SCALE;
	maxy /= SCREEN_SCALE;
	scissor_push(minx,miny,maxx-minx,maxy-miny);
}
Example #12
0
static int
test_child(struct sprite *s, struct srt *srt, struct matrix * ts, int x, int y, struct sprite ** touch) {
	struct matrix temp;
	struct matrix *t = mat_mul(s->t.mat, ts, &temp);
	if (s->type == TYPE_ANIMATION) {
		struct sprite *tmp = NULL;
		int testin = test_animation(s , srt, t, x,y, &tmp);
		if (testin) {
			*touch = tmp;
			return 1;
		} else if (tmp) {
			if (s->message) {
				*touch = s;
				return 1;
			} else {
				*touch = tmp;
				return 0;
			}
		}
	}
	struct matrix mat;
	if (t == NULL) {
		matrix_identity(&mat);
	} else {
		mat = *t;
	}
	matrix_srt(&mat, srt);
	struct matrix imat;
	if (matrix_inverse(&mat, &imat)) {
		// invalid matrix
		*touch = NULL;
		return 0;
	}
	int *m = imat.m;

	int xx = (x * m[0] + y * m[2]) / 1024 + m[4];
	int yy = (x * m[1] + y * m[3]) / 1024 + m[5];

	int testin;
	struct sprite * tmp = s;
	switch (s->type) {
	case TYPE_PICTURE:
		testin = test_quad(s->s.pic, xx, yy);
		break;
	case TYPE_POLYGON:
		testin = test_polygon(s->s.poly, xx, yy);
		break;
	case TYPE_LABEL:
		testin = test_label(s->s.label, xx, yy);
		break;
	case TYPE_PANNEL:
		testin = test_pannel(s->s.pannel, xx, yy);
		break;
	case TYPE_ANCHOR:
		*touch = NULL;
		return 0;
	default:
		// todo : invalid type
		*touch = NULL;
		return 0;
	}

	if (testin) {
		*touch = tmp;
		return s->message;
	} else {
		*touch = NULL;
		return 0;
	}
}