bool textureAtlas::load(const std::string &path, bool smooth)
{
    _log::out("Loading texture atlas : %s\n", path.c_str());
    XMLDocument document;

    if(document.LoadFile(path.c_str()))
        return 0;
    free();

    XMLElement *element = document.FirstChildElement("data");
    uint elCount = 0;
    element->QueryAttribute("size", &elCount);
    elements.reserve(elCount);

    if(!texture::load(path.substr(0,path.rfind('/')+1)+element->Attribute("source"), smooth))
        return 0;
    parameteri(GL_TEXTURE_WRAP_S, GL_CLAMP);
    parameteri(GL_TEXTURE_WRAP_T, GL_CLAMP);
    element = element->FirstChildElement("sprite");

    for(int i = 0;element; i++, element = element->NextSiblingElement())
    {
        textureAtlasNode temp;
        temp.angle = 0;
        temp.scale = vec2f(1);
        temp.color = rgba(1);


        CheckAttribute("x", &temp.pos.x, element);
        CheckAttribute("y", &temp.pos.y, element);
        CheckAttribute("w", &temp.size.x, element);
        CheckAttribute("h", &temp.size.y, element);
        CheckAttribute("pX", &temp.center.x, element);
        CheckAttribute("pY", &temp.center.y, element);

        const char *name = element->Attribute("n");
        if(name)
            temp.name = name;
        else _log::out("[WARNING] Can't find attribute \"n\"\n");

        temp.size += vec2f(1);
        elements.push_back(temp);
    }
    _log::out("Elements count: %d\n", elements.size());
    return 1;
}

int
main(int argc, char **argv)
{
  if (argc < 4) {
    std::cerr << "Usage: test_image_rgb_mask " <<
                 "<ifile> <mfile> <ofile> [r] [g] [b]" << std::endl;
    exit(1);
  }

  CFile ifile(argv[1]);
  CFile mfile(argv[2]);
  CFile ofile(argv[3]);

  double r, g, b;

  if (argc >= 5 && ! CStrUtil::toReal(argv[4], &r)) exit(1);
  if (argc >= 6 && ! CStrUtil::toReal(argv[5], &g)) exit(1);
  if (argc >= 7 && ! CStrUtil::toReal(argv[6], &b)) exit(1);

  CImageFileSrc src1(ifile);

  CImagePtr src_image = CImageMgrInst->createImage(src1);

  CImageFileSrc src2(mfile);

  CImagePtr merge_image = CImageMgrInst->createImage(src2);

  CImagePtr merge_image1;

  if (argc >= 5) {
    CRGBA rgba(r, g, b);

    merge_image1 = merge_image->createRGBAMask(rgba);
  }
  else
    merge_image1 = merge_image->createRGBAMask();

  src_image->combineAlpha(merge_image1);

  CFileType type = CFileUtil::getImageTypeFromName(argv[3]);

  src_image->write(&ofile, type);

  exit(0);
}

extern "C" void reductionKernel(const Range& globalID,const Range& localID,const CPUImage<Vec<3,float>>& input,CPUImage<unsigned>& output){
	Vec<3,float> val{ 0,0,0 };
	if(MULTISAMPLING_ENABLED){
		for(int i = 0; i < MULTISAMPLING_SIZE; i++){
			for(int j = 0; j < MULTISAMPLING_SIZE; j++){
				int xpos = globalID.x * MULTISAMPLING_SIZE + i;
				int ypos = globalID.y * MULTISAMPLING_SIZE + j;
				val += input.at(xpos,ypos);
			}
		}
		val /= (MULTISAMPLING_SIZE * MULTISAMPLING_SIZE);
	}else{
		val = input.at(globalID.x,globalID.y);
	}
	Vec<4,uint8_t> rgba(255 * val);
	rgba[3] = 255; //making the color opaque
	output.at(globalID.x,globalID.y) = reinterpret_cast<uint32_t&>(rgba);
}

raster::color_t color_utils::fixup_color_for_background(PixelFormat format, raster::color_t color)
{
  switch (format) {
    case IMAGE_RGB:
      if (rgba_geta(color) < 255) {
        return rgba(rgba_getr(color),
                    rgba_getg(color),
                    rgba_getb(color), 255);
      }
      break;
    case IMAGE_GRAYSCALE:
      if (graya_geta(color) < 255) {
        return graya(graya_getv(color), 255);
      }
      break;
  }
  return color;
}

int main(int argc, char * argv[])
{
    if (argc < 3) {
        std::cerr<<"usage: "<<argv[0]<<" rgba.tif region.tif"<<std::endl;
        return EXIT_FAILURE;
    }
    gdalwrap::gdal rgba  (argv[1]);
    gdalwrap::gdal region;
    region.names = {"NO_3D_CLASS", "FLAT", "OBSTACLE", "ROUGH"};
    region.copy_meta(rgba, region.names.size());
    color_to_proba(rgba.bands[0], region.get_band("OBSTACLE")); // red
    color_to_proba(rgba.bands[1], region.get_band("FLAT"));     // green
    color_to_proba(rgba.bands[2], region.get_band("ROUGH"));    // blue

    region.save(argv[2]);

    return EXIT_SUCCESS;
}

int youmu_common_particle_slice_logic(Projectile *p, int t) {
    if(t < 0) {
        return 1;
    }

    p->color = rgba(1, 1, 1, 1 - p->args[2]/p->args[0]*20.0);

    if(t < creal(p->args[0])/20.0) {
        p->args[1] += 1;
    }

    if(t > creal(p->args[0])-10) {
        p->args[1] += 3;
        p->args[2] += 1;
    }

    return timeout(p, t);
}

void renderTexture::grapicalPrintf(char* str,   void* fontData, int rasterposx, int rasterposy)
{
    unsigned char c;
    int x = 0;
    int xx = 0;

    while ((c = (unsigned char) * str++))
    {

        x = xx;
        unsigned char* fontPtr = (unsigned char*) fontData;
        char ch = c - 32;

        int sx = ch % 16;
        int sy = ch / 16;


        for (int i = sx * 16; i < (sx * 16 + 16); i++)
        {
            int y = 0;

            for (int j = sy * 16; j < (sy * 16 + 16); j++)
            {
                unsigned char packedColor = (fontPtr[i * 3 + 255 * 256 * 3 - (256 * j) * 3]);
                //float colorf = packedColor ? 0.f : 1.f;
                float colorf = packedColor / 255.f; // ? 0.f : 1.f;
                btVector4 rgba(colorf, colorf, colorf, 1.f);
                //if (colorf)
                {
                    //setPixel(rasterposx+x,rasterposy+y,rgba);
                    addPixel(rasterposx + x, rasterposy + y, rgba);
                }
                //bit >>=1;
                y++;
            }

            x++;
        }

        //xx+=16;
        xx += 10;
    }
}

Sprite::Sprite(PixelFormat format, int width, int height, int ncolors)
  : Object(OBJECT_SPRITE)
  , m_format(format)
  , m_width(width)
  , m_height(height)
  , m_frames(1)
{
  ASSERT(width > 0 && height > 0);

  m_frlens.push_back(100);      // First frame with 100 msecs of duration
  m_stock = new Stock(format);
  m_folder = new LayerFolder(this);

  // Generate palette
  Palette pal(FrameNumber(0), ncolors);

  switch (format) {

    // For colored images
    case IMAGE_RGB:
    case IMAGE_INDEXED:
      pal.resize(ncolors);
      break;

    // For black and white images
    case IMAGE_GRAYSCALE:
    case IMAGE_BITMAP:
      for (int c=0; c<ncolors; c++) {
        int g = 255 * c / (ncolors-1);
        g = MID(0, g, 255);
        pal.setEntry(c, rgba(g, g, g, 255));
      }
      break;
  }

  // Initial RGB map
  m_rgbMap = NULL;

  // The transparent color for indexed images is 0 by default
  m_transparentColor = 0;

  setPalette(&pal, true);
}

Sprite::Sprite(PixelFormat format, int width, int height, int ncolors)
  : Object(ObjectType::Sprite)
  , m_document(NULL)
  , m_format(format)
  , m_width(width)
  , m_height(height)
  , m_frames(1)
  , m_frameTags(this)
{
  ASSERT(width > 0 && height > 0);

  m_frlens.push_back(100);      // First frame with 100 msecs of duration
  m_folder = new LayerFolder(this);

  // Generate palette
  switch (format) {
    case IMAGE_GRAYSCALE: ncolors = 256; break;
    case IMAGE_BITMAP: ncolors = 2; break;
  }

  Palette pal(frame_t(0), ncolors);

  switch (format) {

    // For black and white images
    case IMAGE_GRAYSCALE:
    case IMAGE_BITMAP:
      for (int c=0; c<ncolors; c++) {
        int g = 255 * c / (ncolors-1);
        g = MID(0, g, 255);
        pal.setEntry(c, rgba(g, g, g, 255));
      }
      break;
  }

  // Initial RGB map
  m_rgbMap = NULL;

  // The transparent color for indexed images is 0 by default
  m_transparentColor = 0;

  setPalette(&pal, true);
}

 // traverse tree and search for nodes with count!=0, that represent single color.
 // clip extreme alfa values
 void create_palette_rek(std::vector<rgba> & palette, node * itr) const
 {
     if (itr->count >= 3)
     {
         unsigned count = itr->count;
         byte a = byte(itr->alphas/float(count));
         if (a > InsertPolicy::MAX_ALPHA) a = 255;
         if (a < InsertPolicy::MIN_ALPHA) a = 0;
         palette.push_back(rgba((byte)round(gamma(itr->reds   / count, gamma_)),
                                (byte)round(gamma(itr->greens / count, gamma_)),
                                (byte)round(gamma(itr->blues  / count, gamma_)), a));
     }
     for (unsigned idx=0; idx < 16; ++idx)
     {
         if (itr->children_[idx] != 0)
         {
             create_palette_rek(palette, itr->children_[idx]);
         }
     }
 }

void
shRefract::Shade(const Ray &r, rgba* result) const
{
	rgba Kr;
	mValue->Shade(r, &Kr);
	if (Kr.Luminance() != channel(0.0)) {
		rgba N;
		mCoeficient->Shade(r, &N);

		const real n1 = r.cState.refrN;
		const real n2 = N.Luminance();

		const real n = (r.gState.inside)?(n2/n1):(n1/n2);

		real sin;
		if (n >= real(0.99) && n <= real(0.001)) {
			sin = real(100.0);
		} else {
			sin = real(1.0) - Square(n) * (real(1.0) - Square(r.gState.cosND));
		}


		vec3 refrDir;
		if (n >= real(0.99) && n <= real(0.001)) {
			refrDir = r.dir;
		} else {
			refrDir = r.dir * n + r.gState.normal * (r.gState.cosND * n - sin.Sqrt());
		}


		Ray rayRefr(r.scene, r.gState.point, refrDir, r.cState.depth-1, (r.gState.inside) ? r.parent : &r);
		rayRefr.cState.refrN = n2;
		r.scene->Trace(rayRefr, result);
		if(!r.gState.inside) {
			*result *= Kr;
		}

	} else {
		*result = rgba(0.0);
	}
}

void InfiniteAreaLight::buildDistribution() {
    float ccdf = 0;
    for (int y = 0; y < height; ++y) {
        std::vector<float> row;
        row.reserve(width);

        float cdf = 0;
        for (int x = 0; x < width; ++x) {
            int index = (y * width + x) * 4;
            auto color =
                rgba(data[index + 0], data[index + 1], data[index + 2], 1);
            float w = (color.r + color.g + color.b) / 3.0 + 0.00001;
            cdf += w;
            row.push_back(cdf);
        }

        cdf_columns.push_back(std::move(row));
        ccdf += cdf;
        cdf_rows.push_back(ccdf);
    }
}

// Changes a color of the current system palette
void set_current_color(int index, int r, int g, int b)
{
  int c;

  ASSERT(index >= 0 && index <= 255);
  ASSERT(r >= 0 && r <= 255);
  ASSERT(g >= 0 && g <= 255);
  ASSERT(b >= 0 && b <= 255);

  c = ase_current_palette->getEntry(index);

  if (rgba_getr(c) != r ||
      rgba_getg(c) != g ||
      rgba_getb(c) != b) {
    RGB rgb;

    ase_current_palette->setEntry(index, rgba(r, g, b, 255));

    rgb.r = r>>2;
    rgb.g = g>>2;
    rgb.b = b>>2;

    set_color(index, &rgb);
  }

// Creates a linear ramp in the palette.
void Palette::makeGradient(int from, int to)
{
  int r, g, b, a;
  int r1, g1, b1, a1;
  int r2, g2, b2, a2;
  int i, n;

  ASSERT(from >= 0 && from <= 255);
  ASSERT(to >= 0 && to <= 255);

  if (from > to)
    std::swap(from, to);

  n = to - from;
  if (n < 2)
    return;

  r1 = rgba_getr(getEntry(from));
  g1 = rgba_getg(getEntry(from));
  b1 = rgba_getb(getEntry(from));
  a1 = rgba_geta(getEntry(from));

  r2 = rgba_getr(getEntry(to));
  g2 = rgba_getg(getEntry(to));
  b2 = rgba_getb(getEntry(to));
  a2 = rgba_geta(getEntry(to));

  for (i=from+1; i<to; ++i) {
    r = r1 + (r2-r1) * (i-from) / n;
    g = g1 + (g2-g1) * (i-from) / n;
    b = b1 + (b2-b1) * (i-from) / n;
    a = a1 + (a2-a1) * (i-from) / n;

    setEntry(i, rgba(r, g, b, a));
  }
}

static void
render_gradient_rect_without_gamma_correction(render_context *ctx, rect2 rect) {
    i32 minx = (i32) (rect.min.x);
    i32 miny = (i32) (rect.min.y);
    i32 maxx = (i32) (rect.max.x);
    i32 maxy = (i32) (rect.max.y);

    if (minx < 0) { minx = 0; }
    if (maxx >= ctx->width) { maxx = ctx->width; }
    if (miny < 0) { miny = 0; }
    if (maxy >= ctx->height) { maxy = ctx->height; }

    u32 *row = ctx->buf + (ctx->height - 1 - miny) * ctx->width + minx;
    i32 size = maxx - minx;
    for (i32 y = miny; y < maxy; ++y) {
        u32 *pixel = row;
        for (i32 x = minx; x < maxx; ++x) {
            f32 intensity = (x - minx) * 1.0f / size;
            u32 color = rgba_to_u32(rgba(intensity, intensity, intensity, 1.0f));
            *pixel++ = color;
        }
        row -= ctx->width;
    }
}

    void create_palette(std::vector<rgba> & palette)
    {
        sorted_pal_.clear();
        if (has_holes_)
        {
            max_colors_--;
            sorted_pal_.push_back(rgba(0,0,0,0));
        }
        assign_node_colors();

        sorted_pal_.reserve(colors_);
        create_palette_rek(sorted_pal_, root_.get());

        // sort palette for binary searching in quantization
        std::sort(sorted_pal_.begin(), sorted_pal_.end(), rgba::mean_sort_cmp());
        // returned palette is rearanged, so that colors with a<255 are at the begining
        pal_remap_.resize(sorted_pal_.size());
        palette.clear();
        palette.reserve(sorted_pal_.size());
        for (unsigned i=0; i<sorted_pal_.size(); ++i)
        {
            if (sorted_pal_[i].a<255)
            {
                pal_remap_[i] = static_cast<unsigned>(palette.size());
                palette.push_back(sorted_pal_[i]);
            }
        }
        for (unsigned i=0; i<sorted_pal_.size(); ++i)
        {
            if (sorted_pal_[i].a==255)
            {
                pal_remap_[i] = static_cast<unsigned>(palette.size());
                palette.push_back(sorted_pal_[i]);
            }
        }
    }

 static inline color bgr( float b, float g, float r )
 {
   return rgba( r, g, b, 1.0 );
 }

 static inline color rgb( float r, float g, float b )
 {
   return rgba( r, g, b, 1.0 );
 }

 static inline color argb( float a, float r, float g, float b )
 {
   return rgba( r, g, b, a );
 }

//.........这里部分代码省略.........
        changed_ranges.setSingleMode(!want_multiple_regions());
        
        // scan through all sprites to compute invalidated bounds  
        m->add_invalidated_bounds(changed_ranges, false);
	
        // grow ranges by a 2 pixels to avoid anti-aliasing issues		
        changed_ranges.growBy(40.0f / _xscale);
	
        // optimize ranges
        changed_ranges.combineRanges();	
    }
    
    // TODO: Remove this and want_redraw to avoid confusion!?
    if (redraw_flag)  {
        changed_ranges.setWorld();
    }
    
    // DEBUG ONLY:
    // This is a good place to inspect the invalidated bounds state. Enable
    // the following block (and parts of it) if you need to. 
#if 0
    {
        // This may print a huge amount of information, but is useful to analyze
        // the (visible) object structure of the movie and the flags of the
        // characters. For example, a characters should have set the 
        // m_child_invalidated flag if at least one of it's childs has the
        // invalidated flag set.
        log_debug("DUMPING CHARACTER TREE"); 
        
        InfoTree tr;
        InfoTree::iterator top = tr.begin();
        _stage->getMovieInfo(tr, top);
        
        for (InfoTree::iterator i = tr.begin(), e = tr.end();
             i != e; ++i) {
            std::cout << std::string(tr.depth(i) * 2, ' ') << i->first << ": " << 
                i->second << std::endl;
        }
        
        
        // less verbose, and often necessary: see the exact coordinates of the
        // invalidated bounds (mainly to see if it's NULL or something else).	
        std::cout << "Calculated changed ranges: " << changed_ranges << "\n";
    }
#endif
    
    // Avoid drawing of stopped movies
    if ( ! changed_ranges.isNull() ) { // use 'else'?
        // Tell the GUI(!) that we only need to update this
        // region. Note the GUI can do whatever it wants with
        // this information. It may simply ignore the bounds
        // (which will normally lead into a complete redraw),
        // or it may extend or shrink the bounds as it likes. So,
        // by calling set_invalidated_bounds we have no guarantee
        // that only this part of the stage is rendered again.
#ifdef REGION_UPDATES_DEBUGGING_FULL_REDRAW
        // redraw the full screen so that only the
        // *new* invalidated region is visible
        // (helps debugging)
        InvalidatedRanges world_ranges;
        world_ranges.setWorld();
        setInvalidatedRegions(world_ranges);
#else
        setInvalidatedRegions(changed_ranges);
#endif
        
        // TODO: should this be called even if we're late ?
        beforeRendering();
        
        // Render the frame, if not late.
        // It's up to the GUI/renderer combination
        // to do any clipping, if desired.     
        m->display();
        
        // show invalidated region using a red rectangle
        // (Flash debug style)
        IF_DEBUG_REGION_UPDATES (
            if (_renderer.get() && !changed_ranges.isWorld()) {
                for (size_t rno = 0; rno < changed_ranges.size(); rno++) {
                    const geometry::Range2d<int>& bounds = 
                        changed_ranges.getRange(rno);
                    
                    float xmin = bounds.getMinX();
                    float xmax = bounds.getMaxX();
                    float ymin = bounds.getMinY();
                    float ymax = bounds.getMaxY();
                    
                    const std::vector<point> box = {
                        point(xmin, ymin),
                        point(xmax, ymin),
                        point(xmax, ymax),
                        point(xmin, ymax)
                    };
                    
                    _renderer->draw_poly(box, rgba(0,0,0,0), rgba(255,0,0,255),
                                         SWFMatrix(), false);
                    
                }
            }
        );