Render the particles in the system

@param x The x coordinate to render the particle system at (in the current coordinate space)
@param y The y coordinate to render the particle system at (in the current coordiante space)
973793
public void render(float x, float y) {
		if ((sprite == null) && (defaultImageName != null)) {
			loadSystemParticleImage();
		}
		
		if (!visible) {
			return;
		}
		
		GL.glTranslatef(x,y,0);
		
		if (blendingMode == BLEND_ADDITIVE) {
			GL.glBlendFunc(SGL.GL_SRC_ALPHA, SGL.GL_ONE);
		}
		if (usePoints()) {
			GL.glEnable( SGL.GL_POINT_SMOOTH ); 
			TextureImpl.bindNone();
		}
		
		// iterate over all emitters
		for( int emitterIdx=0; emitterIdx<emitters.size(); emitterIdx++ )
		{
			// get emitter
			ParticleEmitter emitter = (ParticleEmitter) emitters.get(emitterIdx);
			
			if (!emitter.isEnabled()) {
				continue;
			}
			
			// check for additive override and enable when set
			if (emitter.useAdditive()) {
				GL.glBlendFunc(SGL.GL_SRC_ALPHA, SGL.GL_ONE);
			}
			
			// now get the particle pool for this emitter and render all particles that are in use
			ParticlePool pool = (ParticlePool) particlesByEmitter.get(emitter);
			Image image = emitter.getImage();
			if (image == null) {
				image = this.sprite;
			}
			
			if (!emitter.isOriented() && !emitter.usePoints(this)) {
				image.startUse();
			}
			
			for (int i = 0; i < pool.particles.length; i++)
			{
				if (pool.particles[i].inUse())
					pool.particles[i].render();
			} 
			
			if (!emitter.isOriented() && !emitter.usePoints(this)) {
				image.endUse();
			}

			// reset additive blend mode
			if (emitter.useAdditive()) {
				GL.glBlendFunc(SGL.GL_SRC_ALPHA, SGL.GL_ONE_MINUS_SRC_ALPHA);
			}
		}

		if (usePoints()) {
			GL.glDisable( SGL.GL_POINT_SMOOTH ); 
		}
		if (blendingMode == BLEND_ADDITIVE) {
			GL.glBlendFunc(SGL.GL_SRC_ALPHA, SGL.GL_ONE_MINUS_SRC_ALPHA);
		}
		
		Color.white.bind();
		GL.glTranslatef(-x,-y,0);
	}
317207
@Override
	public void draw(float x, float y) {
		init();
		draw(x,y,width,height);
	}
687335
public void setLocation(float x, float y) {
		if (area != null) {
			area.setX(x);
			area.setY(y);
		}
	}
988467
public void vertex(double x, double y, double z) {
        MODE = LINES_3D;
        this.cornerX.add(x);
        this.cornerY.add(y);
        this.cornerZ.add(z);
        setNumberOfCorner(this.cornerX.size());
        calcG();
    }
1348161
private static void createFunctionDraw(Graphic g, CollisionFormula formula, int tw, int th)
    {
        for (int x = 0; x < tw; x++)
        {
            for (int y = 0; y < th; y++)
            {
                renderCollision(g, formula, th, x, y);
            }
        }
    }
1082462
public void add(double x, double y) {
    data.add(x);
    data.add(y);
    minx = Math.min(minx, x);
    maxx = Math.max(maxx, x);
    miny = Math.min(miny, y);
    maxy = Math.max(maxy, y);
  }
620120
@Override
    public void renderCharset( PositionedText target, double x, double y, String text, String set )
    {
        target.add( x, y, text );
    }
281279
public void show(JComponent comp, int x, int y) {
        this.x = x;
        this.y = y;
        super.show(comp, x, y);
    }
943293
public void vertex(double x, double y) {
        MODE = LINES;
        this.x.add(x);
        this.y.add(y);
        colors.add(this.strokeColor);
        calcG();
    }
234634
function(x, y){
            this.body.setPos(new cp.Vect(x, y));
            if(this.body.isStaticBody){
                this.space.needReindexStatic = true;
            }
        }
497707
@Override
    protected void drawBase (Graphics2D gfx, int x, int y)
    {
        if (_active) {
            // render the sausage
            super.drawBase(gfx, x, y);

        } else {
            // render the circle
            gfx.fillOval(x, y, closedBounds.width - 1, closedBounds.height - 1);
        }
    }
803421
public void render(Graphics g) {
		// last list generation
		if (list == -1) {
			list = GL.glGenLists(1);
			GL.glNewList(list, SGL.GL_COMPILE);
				render(g, diagram);
			GL.glEndList();
		}
		
		GL.glCallList(list);
		
		TextureImpl.bindNone();
	}
101320
public void vertex(double x, double y, double z) {
        MODE = LINES_3D;
        this.x.add(x);
        this.y.add(y);
        this.z.add(z);
        colors.add(this.strokeColor);
        calcG();
    }
502318
protected void drawBase (Graphics2D gfx, int x, int y)
    {
        gfx.fillRoundRect(
            x, y, _size.width - 1, _size.height - 1, _dia, _dia);
    }
613144
public void scale(double x, double y) {
		xx *= x;
		xy *= x;
		xd *= x;
		yx *= y;
		yy *= y;
		yd *= y;
	}
886700
private static void renderY(Graphic g, CollisionFunction function, CollisionRange range, int th, int x)
    {
        if (UtilMath.isBetween(x, range.getMinX(), range.getMaxX()))
        {
            g.drawRect(x, th - function.getRenderY(x) - 1, 0, 0, false);
        }
    }
744387
function (renderer, x, y, tmxTile) {
            var tileset = tmxTile.tileset;
            var point = this.tileToPixelCoords(x, y, me.pool.pull("me.Vector2d"));

            // draw the tile
            tileset.drawTile(
                renderer,
                tileset.tileoffset.x + point.x,
                tileset.tileoffset.y + point.y + (this.tileheight - tileset.tileheight),
                tmxTile
            );

            me.pool.push(point);
        }