public AsFragmentFilter(int numPasses, float resolution)
 {
     if (AsCapabilities.getIsDebugger() && AsGlobal.getQualifiedClassName(this) == "starling.filters::FragmentFilter")
     {
         throw new AsAbstractClassError();
     }
     if (numPasses < 1)
     {
         throw new AsArgumentError("At least one pass is required.");
     }
     mNumPasses  = numPasses;
     mMarginX    = mMarginY = 0.0f;
     mOffsetX    = mOffsetY = 0;
     mResolution = resolution;
     mMode       = AsFragmentFilterMode.REPLACE;
     mVertexData = new AsVertexData(4);
     mVertexData.setTexCoords(0, 0, 0);
     mVertexData.setTexCoords(1, 1, 0);
     mVertexData.setTexCoords(2, 0, 1);
     mVertexData.setTexCoords(3, 1, 1);
     mIndexData = new AsVector <uint>();
     mIndexData.setOwnProperty("_fixed", true);
     createPrograms();
     AsStarling.getCurrent().getStage3D().addEventListener(AsEvent.CONTEXT3D_CREATE, onContextCreated, false, 0, true);
 }
 public AsQuadBatch()
 {
     mVertexData   = new AsVertexData(0, true);
     mIndexData    = new AsVector <uint>();
     mNumQuads     = 0;
     mTinted       = false;
     mSyncRequired = false;
     AsStarling.getCurrent().getStage3D().addEventListener(AsEvent.CONTEXT3D_CREATE, onContextCreated, false, 0, true);
 }
        private static AsDictionary getBitmapFonts()
        {
            AsDictionary fonts = AsStarling.getCurrent().getCustomData()[BITMAP_FONT_DATA_NAME] as AsDictionary;

            if (fonts == null)
            {
                fonts = new AsDictionary();
                AsStarling.getCurrent().getCustomData()[BITMAP_FONT_DATA_NAME] = fonts;
            }
            return(fonts);
        }
 public virtual void restoreOnLostContext(Object data)
 {
     if (mData == null && data != null)
     {
         AsStarling.getCurrent().addEventListener(AsEvent.CONTEXT3D_CREATE, onContextCreated);
     }
     if (data == null)
     {
         AsStarling.getCurrent().removeEventListener(AsEvent.CONTEXT3D_CREATE, onContextCreated);
     }
     mData = data;
 }
 public override void dispose()
 {
     AsStarling.getCurrent().getStage3D().removeEventListener(AsEvent.CONTEXT3D_CREATE, onContextCreated);
     if (mVertexBuffer != null)
     {
         mVertexBuffer.dispose();
     }
     if (mIndexBuffer != null)
     {
         mIndexBuffer.dispose();
     }
     base.dispose();
 }
        private void calculateBounds(AsDisplayObject _object, AsStage stage, AsRectangle resultRect)
        {
            if (_object == stage || _object == AsStarling.getCurrent().getRoot())
            {
                resultRect.setTo(0, 0, stage.getStageWidth(), stage.getStageHeight());
            }
            else
            {
                _object.getBounds(stage, resultRect);
            }
            float deltaMargin = mResolution == 1.0f ? 0.0f : 1.0f / mResolution;

            resultRect.x      = resultRect.x - mMarginX + deltaMargin;
            resultRect.y      = resultRect.y - mMarginY + deltaMargin;
            resultRect.width  = resultRect.width + 2 * (mMarginX + deltaMargin);
            resultRect.height = resultRect.height + 2 * (mMarginY + deltaMargin);
            resultRect.width  = AsGlobal.getNextPowerOfTwo((int)(resultRect.width * mResolution)) / mResolution;
            resultRect.height = AsGlobal.getNextPowerOfTwo((int)(resultRect.height * mResolution)) / mResolution;
        }
        public virtual void renderCustom(AsMatrix mvpMatrix, float parentAlpha, String blendMode)
        {
            if (mNumQuads == 0)
            {
                return;
            }
            if (mSyncRequired)
            {
                syncBuffers();
            }
            bool        pma         = mVertexData.getPremultipliedAlpha();
            AsContext3D context     = AsStarling.getContext();
            bool        tinted      = mTinted || (parentAlpha != 1.0f);
            String      programName = mTexture != null?getImageProgramName(tinted, mTexture.getMipMapping(), mTexture.getRepeat(), mTexture.getFormat(), mSmoothing) : QUAD_PROGRAM_NAME;

            sRenderAlpha[0] = sRenderAlpha[1] = sRenderAlpha[2] = pma ? parentAlpha : 1.0f;
            sRenderAlpha[3] = parentAlpha;
            AsMatrixUtil.convertTo3D(mvpMatrix, sRenderMatrix);
            AsRenderSupport.setBlendFactors(pma, blendMode != null ? blendMode : this.getBlendMode());
            context.setProgram(AsStarling.getCurrent().getProgram(programName));
            context.setProgramConstantsFromVector(AsContext3DProgramType.VERTEX, 0, sRenderAlpha, 1);
            context.setProgramConstantsFromMatrix(AsContext3DProgramType.VERTEX, 1, sRenderMatrix, true);
            context.setVertexBufferAt(0, mVertexBuffer, AsVertexData.POSITION_OFFSET, AsContext3DVertexBufferFormat.FLOAT_2);
            if (mTexture == null || tinted)
            {
                context.setVertexBufferAt(1, mVertexBuffer, AsVertexData.COLOR_OFFSET, AsContext3DVertexBufferFormat.FLOAT_4);
            }
            if (mTexture != null)
            {
                context.setTextureAt(0, mTexture.get_base());
                context.setVertexBufferAt(2, mVertexBuffer, AsVertexData.TEXCOORD_OFFSET, AsContext3DVertexBufferFormat.FLOAT_2);
            }
            context.drawTriangles(mIndexBuffer, 0, mNumQuads * 2);
            if (mTexture != null)
            {
                context.setTextureAt(0, null);
                context.setVertexBufferAt(2, null);
            }
            context.setVertexBufferAt(1, null);
            context.setVertexBufferAt(0, null);
        }
        private AsQuadBatch renderPasses(AsDisplayObject _object, AsRenderSupport support, float parentAlpha, bool intoCache)
        {
            AsTexture   cacheTexture = null;
            AsStage     stage        = _object.getStage();
            AsContext3D context      = AsStarling.getContext();
            float       scale        = AsStarling.getCurrent().getContentScaleFactor();

            if (stage == null)
            {
                throw new AsError("Filtered object must be on the stage.");
            }
            if (context == null)
            {
                throw new AsMissingContextError();
            }
            support.finishQuadBatch();
            support.raiseDrawCount((uint)(mNumPasses));
            support.pushMatrix();
            support.setBlendMode(AsBlendMode.NORMAL);
            AsRenderSupport.setBlendFactors(PMA);
            mProjMatrix.copyFrom(support.getProjectionMatrix());
            AsTexture previousRenderTarget = support.getRenderTarget();

            if (previousRenderTarget != null)
            {
                throw new AsIllegalOperationError("It's currently not possible to stack filters! " + "This limitation will be removed in a future Stage3D version.");
            }
            calculateBounds(_object, stage, sBounds);
            updateBuffers(context, sBounds);
            updatePassTextures((int)(sBounds.width), (int)(sBounds.height), mResolution * scale);
            if (intoCache)
            {
                cacheTexture = AsTexture.empty((int)(sBounds.width), (int)(sBounds.height), PMA, true, mResolution * scale);
            }
            support.setRenderTarget(mPassTextures[0]);
            support.clear();
            support.setOrthographicProjection(sBounds.x, sBounds.y, sBounds.width, sBounds.height);
            _object.render(support, parentAlpha);
            support.finishQuadBatch();
            AsRenderSupport.setBlendFactors(PMA);
            support.loadIdentity();
            context.setVertexBufferAt(0, mVertexBuffer, AsVertexData.POSITION_OFFSET, AsContext3DVertexBufferFormat.FLOAT_2);
            context.setVertexBufferAt(1, mVertexBuffer, AsVertexData.TEXCOORD_OFFSET, AsContext3DVertexBufferFormat.FLOAT_2);
            int i = 0;

            for (; i < mNumPasses; ++i)
            {
                if (i < mNumPasses - 1)
                {
                    support.setRenderTarget(getPassTexture(i + 1));
                    support.clear();
                }
                else
                {
                    if (intoCache)
                    {
                        support.setRenderTarget(cacheTexture);
                        support.clear();
                    }
                    else
                    {
                        support.setRenderTarget(previousRenderTarget);
                        support.getProjectionMatrix().copyFrom(mProjMatrix);
                        support.translateMatrix(mOffsetX, mOffsetY);
                        support.setBlendMode(_object.getBlendMode());
                        support.applyBlendMode(PMA);
                    }
                }
                AsTexture passTexture = getPassTexture(i);
                context.setProgramConstantsFromMatrix(AsContext3DProgramType.VERTEX, 0, support.getMvpMatrix3D(), true);
                context.setTextureAt(0, passTexture.get_base());
                activate(i, context, passTexture);
                context.drawTriangles(mIndexBuffer, 0, 2);
                deactivate(i, context, passTexture);
            }
            context.setVertexBufferAt(0, null);
            context.setVertexBufferAt(1, null);
            context.setTextureAt(0, null);
            support.popMatrix();
            if (intoCache)
            {
                support.setRenderTarget(previousRenderTarget);
                support.getProjectionMatrix().copyFrom(mProjMatrix);
                AsQuadBatch quadBatch = new AsQuadBatch();
                AsImage     image     = new AsImage(cacheTexture);
                stage.getTransformationMatrix(_object, sTransformationMatrix);
                AsMatrixUtil.prependTranslation(sTransformationMatrix, sBounds.x + mOffsetX, sBounds.y + mOffsetY);
                quadBatch.addImage(image, 1.0f, sTransformationMatrix);
                return(quadBatch);
            }
            else
            {
                return(null);
            }
        }