bool
CurveGradient::accelerated_render(Context context,Surface *surface,int quality, const RendDesc &renddesc, ProgressCallback *cb)const
{
RENDER_TRANSFORMED_IF_NEED(__FILE__, __LINE__)
SuperCallback supercb(cb,0,9500,10000);
if(get_amount()==1.0 && get_blend_method()==Color::BLEND_STRAIGHT)
{
surface->set_wh(renddesc.get_w(),renddesc.get_h());
}
else
{
if(!context.accelerated_render(surface,quality,renddesc,&supercb))
return false;
if(get_amount()==0)
return true;
}
int x,y;
Surface::pen pen(surface->begin());
const Real pw(renddesc.get_pw()),ph(renddesc.get_ph());
Point pos;
Point tl(renddesc.get_tl());
const int w(surface->get_w());
const int h(surface->get_h());
if(get_amount()==1.0 && get_blend_method()==Color::BLEND_STRAIGHT)
{
for(y=0,pos[1]=tl[1];y<h;y++,pen.inc_y(),pen.dec_x(x),pos[1]+=ph)
for(x=0,pos[0]=tl[0];x<w;x++,pen.inc_x(),pos[0]+=pw)
pen.put_value(color_func(pos,quality,calc_supersample(pos,pw,ph)));
}
else
{
for(y=0,pos[1]=tl[1];y<h;y++,pen.inc_y(),pen.dec_x(x),pos[1]+=ph)
for(x=0,pos[0]=tl[0];x<w;x++,pen.inc_x(),pos[0]+=pw)
pen.put_value(Color::blend(color_func(pos,quality,calc_supersample(pos,pw,ph)),pen.get_value(),get_amount(),get_blend_method()));
}
// Mark our progress as finished
if(cb && !cb->amount_complete(10000,10000))
return false;
return true;
}
void src_shape(RenBase& rbase, color c1, color c2,
double x1, double y1, double x2, double y2)
{
typedef RenBase renderer_base_type;
typedef agg::gradient_x gradient_func_type;
typedef agg::gradient_linear_color<color> color_func_type;
typedef agg::span_interpolator_linear<> interpolator_type;
typedef agg::span_allocator<color> span_allocator_type;
typedef agg::span_gradient<color,
interpolator_type,
gradient_func_type,
color_func_type> span_gradient_type;
gradient_func_type gradient_func; // The gradient function
agg::trans_affine gradient_mtx = gradient_affine(x1, y1, x2, y2, 100);
interpolator_type span_interpolator(gradient_mtx); // Span interpolator
span_allocator_type span_allocator; // Span Allocator
color_func_type color_func(c1, c2);
span_gradient_type span_gradient(span_interpolator,
gradient_func,
color_func,
0, 100);
agg::rasterizer_scanline_aa<> ras;
agg::scanline_u8 sl;
agg::rounded_rect shape(x1, y1, x2, y2, 40);
// agg::ellipse shape((x1+x2)/2, (y1+y2)/2, fabs(x2-x1)/2, fabs(y2-y1)/2, 100);
ras.add_path(shape);
agg::render_scanlines_aa(ras, sl, rbase, span_allocator, span_gradient);
}
Color
CurveGradient::get_color(Context context, const Point &point)const
{
const Color color(color_func(point,0));
if(get_amount()==1.0 && get_blend_method()==Color::BLEND_STRAIGHT)
return color;
else
return Color::blend(color,context.get_color(point),get_amount(),get_blend_method());
}
int main(){
int year;
int color;
unsigned long long position;
scanf("%d",&year);
scanf("%llu",&position);
color = color_func(year,position);
if(color==0)
printf("red\n");
else printf("blue\n");
getch();
return 0;
}
/* We'll override the plot function to make pixels with very
* disparate subsample values darker. This produces a i
* really cool effect when used with an otherwise bright
* colormap.
*/
virtual int plot() {
assert( screen_init );
percent_counter pc(screen->h * screen->w);
if (verbosity > 0) pc.start();
for (int y = 0; y < screen->h; ++y) {
for (int x = 0; x < screen->w; ++x) {
if (!working) return 1;
color cval = RGBcolor(0, 0, 0);
for (int k = 0; k < sres; ++k) {
for (int j = 0; j < sres; ++j) {
double sx = (k+0.5)/sres;
double sy = (j+0.5)/sres;
cval += color_func(to_plane(x+sx, y+sy));
}
}
cval /= sres * sres;
/* Here's the change: basically, set
* the value to the saturation.
*/
double b = min(min(cval.r, cval.g), cval.b);
cval.r -= b;
cval.g -= b;
cval.b -= b;
set_pixel(x, y, cval.r, cval.g, cval.b);
if (verbosity > 0) pc.count();
}
}
working = false;
update();
return 0;
}
int color_func(int n,unsigned long long k){
unsigned long long above;
int result;
if((n==0)&&(k==0))
return 0;
else{
above = k/2;
}
result = color_func(n-1,above);
if(k == 2*above){
if(result == 0)
result = 1;
else result = 0;
}
else{
if(result == 0)
result = 0;
else result = 1;
}
return result;
}
void circle(RenBase& rbase, color c1, color c2,
double x1, double y1, double x2, double y2,
double shadow_alpha)
{
typedef RenBase renderer_base_type;
typedef agg::gradient_x gradient_func_type;
typedef agg::gradient_linear_color<color> color_func_type;
typedef agg::span_interpolator_linear<> interpolator_type;
typedef agg::span_allocator<color> span_allocator_type;
typedef agg::span_gradient<color,
interpolator_type,
gradient_func_type,
color_func_type> span_gradient_type;
gradient_func_type gradient_func; // The gradient function
agg::trans_affine gradient_mtx = gradient_affine(x1, y1, x2, y2, 100);
interpolator_type span_interpolator(gradient_mtx); // Span interpolator
span_allocator_type span_allocator; // Span Allocator
color_func_type color_func(c1, c2);
span_gradient_type span_gradient(span_interpolator,
gradient_func,
color_func,
0, 100);
agg::rasterizer_scanline_aa<> ras;
agg::scanline_u8 sl;
double r = agg::calc_distance(x1, y1, x2, y2) / 2;
agg::ellipse ell((x1+x2)/2+5, (y1+y2)/2-3, r, r, 100);
ras.add_path(ell);
agg::render_scanlines_aa_solid(ras, sl, rbase,
agg::rgba(0.6, 0.6, 0.6, 0.7*shadow_alpha));
ell.init((x1+x2)/2, (y1+y2)/2, r, r, 100);
ras.add_path(ell);
agg::render_scanlines_aa(ras, sl, rbase, span_allocator, span_gradient);
}
static unsigned char *calc(t_tmp *tmp, t_obj *obc, t_cod *cor, t_sph *obj_a)
{
t_sph *tm;
tm = obj_a;
obc->nt = NULL;
obc->color = 0;
calcul_X1(cor->x / 4, cor->y, cor->l_x);
rotate_x(cor->l_o[3], cor->l_o[4], cor->l_o[5], cor->l_x);
while (obj_a != NULL)
{
if (obj_a->type >= 0 && obj_a->type < 20 && obc->inter[obj_a->type]
&& obc->inter[obj_a->type](cor, tmp, obc, obj_a) == 1
&& obj_a->negative != -1)
obc->nt = obj_a;
else if (obj_a->type >= 0 && obj_a->type < 20 && obc->inter[obj_a->type]
&& obc->inter[obj_a->type](cor, tmp, obc, obj_a) == 1
&& obj_a->negative == - 1)
obc->nt = NULL;
obj_a = obj_a->nt;
}
calc_p_n_color(cor, obc, obc->nt, tmp);
return (color_func(obc, tm, tmp));
}
synfig::Layer::Handle
LinearGradient::hit_check(synfig::Context context, const synfig::Point &point)const
{
if(get_blend_method()==Color::BLEND_STRAIGHT && get_amount()>=0.5)
return const_cast<LinearGradient*>(this);
if(get_amount()==0.0)
return context.hit_check(point);
if((get_blend_method()==Color::BLEND_STRAIGHT || get_blend_method()==Color::BLEND_COMPOSITE) && color_func(point).get_a()>0.5)
return const_cast<LinearGradient*>(this);
return context.hit_check(point);
}
bool
CurveGradient::accelerated_cairorender(Context context, cairo_t *cr,int quality, const RendDesc &renddesc_, ProgressCallback *cb)const
{
RendDesc renddesc(renddesc_);
// Untransform the render desc
if(!cairo_renddesc_untransform(cr, renddesc))
return false;
Point pos;
const Real pw(renddesc.get_pw()),ph(renddesc.get_ph());
const Point tl(renddesc.get_tl());
const int w(renddesc.get_w());
const int h(renddesc.get_h());
SuperCallback supercb(cb,0,9500,10000);
if(get_amount()==1.0 && get_blend_method()==Color::BLEND_STRAIGHT)
{
cairo_save(cr);
cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
cairo_paint(cr);
cairo_restore(cr);
}
else
{
if(!context.accelerated_cairorender(cr,quality,renddesc,&supercb))
return false;
if(get_amount()==0)
return true;
}
int x,y;
cairo_surface_t *surface;
surface=cairo_surface_create_similar(cairo_get_target(cr), CAIRO_CONTENT_COLOR_ALPHA, w, h);
CairoSurface csurface(surface);
if(!csurface.map_cairo_image())
{
synfig::warning("Curve Gradient: map cairo surface failed");
return false;
}
for(y=0,pos[1]=tl[1]; y<h; y++,pos[1]+=ph)
for(x=0,pos[0]=tl[0]; x<w; x++,pos[0]+=pw)
csurface[y][x]=CairoColor(color_func(pos,calc_supersample(pos,pw,ph))).premult_alpha();
csurface.unmap_cairo_image();
// paint surface on cr
cairo_save(cr);
cairo_translate(cr, tl[0], tl[1]);
cairo_scale(cr, pw, ph);
cairo_set_source_surface(cr, surface, 0, 0);
cairo_paint_with_alpha_operator(cr, get_amount(), get_blend_method());
cairo_restore(cr);
cairo_surface_destroy(surface);
// Mark our progress as finished
if(cb && !cb->amount_complete(10000,10000))
return false;
return true;
}
bool
LinearGradient::accelerated_render(Context context,Surface *surface,int quality, const RendDesc &renddesc, ProgressCallback *cb)const
{
Params params;
fill_params(params);
if (!renddesc.get_transformation_matrix().is_identity())
{
Point origin = params.p1;
Point axis_x = params.p2 - origin;
Point axis_y = axis_x.perp();
origin = renddesc.get_transformation_matrix().get_transformed(origin);
axis_x = renddesc.get_transformation_matrix().get_transformed(axis_x, false);
axis_y = renddesc.get_transformation_matrix().get_transformed(axis_y, false);
Point valid_axis_x = -axis_y.perp();
Real mag_squared = valid_axis_x.mag_squared();
if (mag_squared > 0.0)
valid_axis_x *= (valid_axis_x * axis_x)/mag_squared;
else
valid_axis_x = axis_x;
params.p1 = origin;
params.p2 = origin + valid_axis_x;
params.calc_diff();
}
SuperCallback supercb(cb,0,9500,10000);
if(get_amount()==1.0 && get_blend_method()==Color::BLEND_STRAIGHT)
{
surface->set_wh(renddesc.get_w(),renddesc.get_h());
}
else
{
if(!context.accelerated_render(surface,quality,renddesc,&supercb))
return false;
if(get_amount()==0)
return true;
}
int x,y;
Surface::pen pen(surface->begin());
const Real pw(renddesc.get_pw()),ph(renddesc.get_ph());
Point pos;
Point tl(renddesc.get_tl());
const int w(surface->get_w());
const int h(surface->get_h());
synfig::Real supersample = calc_supersample(params, pw, ph);
if(get_amount()==1.0 && get_blend_method()==Color::BLEND_STRAIGHT)
{
for(y=0,pos[1]=tl[1];y<h;y++,pen.inc_y(),pen.dec_x(x),pos[1]+=ph)
for(x=0,pos[0]=tl[0];x<w;x++,pen.inc_x(),pos[0]+=pw)
pen.put_value(color_func(params,pos,supersample));
}
else
{
for(y=0,pos[1]=tl[1];y<h;y++,pen.inc_y(),pen.dec_x(x),pos[1]+=ph)
for(x=0,pos[0]=tl[0];x<w;x++,pen.inc_x(),pos[0]+=pw)
pen.put_value(Color::blend(color_func(params,pos,supersample),pen.get_value(),get_amount(),get_blend_method()));
}
// Mark our progress as finished
if(cb && !cb->amount_complete(10000,10000))
return false;
return true;
}
