// providers
    private CharacterPartsProvider skinProvider = null;
    private EnumMap<EquipSlot, CharacterPartsProvider> equipsProvider = new EnumMap(EquipSlot.class);
    private CharacterPartsProvider hairProvider = null;
    private CharacterPartsProvider faceProvider = null;
    // rendering stuff
    private Set<CharacterPart> currentParts = new TreeSet<CharacterPart>(CHAR_PART_Z_COMPARATOR);
    private CharacterStance lastRenderedStance = null;
    private int lastFrame = -1;
    private boolean partsDirty = false;
    
    ///////////////////////////////////////////////////////////////////////////
    static final Comparator<CharacterPart> CHAR_PART_Z_COMPARATOR = new Comparator<CharacterPart>() {

        public int compare(CharacterPart o1, CharacterPart o2) {
            return o1.z - o2.z;
        }
        
    };

    @Override
    public void doRender(RenderSpace g) {
        if (morph != null) {
            morph.doRender(this, g);
            return;
        }
        
        if (lastRenderedStance != stance || lastFrame != frame || partsDirty) {
            currentParts.clear();
            // provide skin
            skinProvider.provide(currentParts, stance, frame);
            // provide hair
            if (hairProvider != null) {
                hairProvider.provide(currentParts, stance, frame);
            }
            if (faceProvider != null) {
                faceProvider.provide(currentParts, stance, frame);
            }
            // provide equips
            for (final CharacterPartsProvider provider : equipsProvider.values()) {
                provider.provide(currentParts, stance, frame);
            }
            
            // set state
            lastRenderedStance = stance;
            lastFrame = frame;
            partsDirty = false;
        }

        this.update();
        this.constrainFrame();

        if (renoria.Core.systemTime() - getLastTalk() > 3500) {
            chatBubble = null;
        }

        Rectangle r = getArea();
        
        boolean flip = direction == ObjectDirection.RIGHT && !noFlip();
        
        for (Iterator<CharacterPart> i = currentParts.iterator(); i.hasNext();) {
            CharacterPart part = i.next();
            int charX = x + r.width/2 - Core.view.x;
            int charY = y + r.height - Core.view.y;
            part.draw(charX, charY, g, flip);
        }
        
        // [EFFECTS]
        for (int i = 0; i < effects.size(); i++) {
            effects.get(i).doRender(g);
        }
        // [END EFFECTS]
        
        //drawDebugBoundaries(g);
    }

    public static BufferedImage toCompatibleImage(BufferedImage image, boolean override, boolean disposeOld) {
        if (image.getColorModel().equals(gfxConfig.getColorModel()) && !override) {
            return image;
        }
        BufferedImage newImage = gfxConfig.createCompatibleImage(image.getWidth(), image.getHeight(), image.getTransparency());
        Graphics2D g2d = newImage.createGraphics();
        g2d.drawImage(image, 0, 0, null);
        g2d.dispose();
        if (disposeOld) {
            image.flush();
        }

        return newImage;
    }

drawCanvas = new RenoriaCanvas();
        drawCanvas.setSize(RenoriaSize);
        drawCanvas.setPreferredSize(RenoriaSize);
        panel.add(drawCanvas);
        drawCanvas.setFocusTraversalKeysEnabled(false);
        drawCanvas.requestFocus();
        drawCanvas.setIgnoreRepaint(true);
if (Core.useDrawBuffers.getValue()) {
            drawCanvas.createBufferStrategy(RenoriaOptions.BufferCount.getValue());
            this.buffer = drawCanvas.getBufferStrategy();
        } else {
            drawBuffer = ImageFactory.gfxConfig.createCompatibleImage(RenoriaSize.width, RenoriaSize.height, BufferedImage.OPAQUE);
            drawBuffer = ImageFactory.gfxConfig.createCompatibleImage(RenoriaSize.width, RenoriaSize.height, BufferedImage.OPAQUE);
        }
        this.renderSpace = new RenderSpace();

public void render() {
            if (!render) {
                return;
            }
            if (drawBuffer != null) {
                renderInternal(drawBuffer.createGraphics());
                drawCanvas.update(drawCanvas.getGraphics());
                return;
            }
            Graphics2D g = (Graphics2D) buffer.getDrawGraphics();
            renderInternal(g);
            buffer.show();
            if (RenoriaOptions.UseVsync.getValue()) {
                Toolkit.getDefaultToolkit().sync();
            }

    }

public void doRender(RenderSpace g) {
   TreeSet<MapObject> objList = new TreeSet<MapObject>(MAP_OBJECT_Z_COMPARATOR);
   currentMap.getObjectsInRegionQuadTree(Core.viewX, Core.viewY, Core.viewWidth, Core.viewHeight, objList);
   
   for (Iterator<MapObject> i = objList.iterator(); i.hasNext();) {
      i.next().doRender(g);
   }
}