private void createBuffers()
{
int numVertices = mVertexData.getNumVertices();
int numIndices = (int)(mIndexData.getLength());
AsContext3D context = AsStarling.getContext();
if (mVertexBuffer != null)
{
mVertexBuffer.dispose();
}
if (mIndexBuffer != null)
{
mIndexBuffer.dispose();
}
if (numVertices == 0)
{
return;
}
if (context == null)
{
throw new AsMissingContextError();
}
mVertexBuffer = context.createVertexBuffer(numVertices, AsVertexData.ELEMENTS_PER_VERTEX);
mVertexBuffer.uploadFromVector(mVertexData.getRawData(), 0, numVertices);
mIndexBuffer = context.createIndexBuffer(numIndices);
mIndexBuffer.uploadFromVector(mIndexData, 0, numIndices);
mSyncRequired = false;
}
public static AsTexture empty(int width, int height, bool premultipliedAlpha, bool optimizeForRenderTexture, float scale)
{
if (scale <= 0)
{
scale = AsStarling.getContentScaleFactor();
}
int origWidth = (int)(width * scale);
int origHeight = (int)(height * scale);
int legalWidth = AsGlobal.getNextPowerOfTwo(origWidth);
int legalHeight = AsGlobal.getNextPowerOfTwo(origHeight);
String format = AsContext3DTextureFormat.BGRA;
AsContext3D context = AsStarling.getContext();
if (context == null)
{
throw new AsMissingContextError();
}
bc.flash.display3D.textures.AsTexture nativeTexture = context.createTexture(legalWidth, legalHeight, AsContext3DTextureFormat.BGRA, optimizeForRenderTexture);
AsConcreteTexture concreteTexture = new AsConcreteTexture(nativeTexture, format, legalWidth, legalHeight, false, premultipliedAlpha, optimizeForRenderTexture, scale);
if (origWidth == legalWidth && origHeight == legalHeight)
{
return(concreteTexture);
}
else
{
return(new AsSubTexture(concreteTexture, new AsRectangle(0, 0, width, height), true));
}
}
public virtual void clear()
{
AsContext3D context = AsStarling.getContext();
if (context == null)
{
throw new AsMissingContextError();
}
mSupport.setRenderTarget(mActiveTexture);
mSupport.clear();
mSupport.setRenderTarget(null);
}
public virtual void drawBundled(AsDrawingBlockCallback drawingBlock, int antiAliasing)
{
float scale = mActiveTexture.getScale();
AsContext3D context = AsStarling.getContext();
if (context == null)
{
throw new AsMissingContextError();
}
sScissorRect.setTo(0, 0, mActiveTexture.getWidth() * scale, mActiveTexture.getHeight() * scale);
context.setScissorRectangle(sScissorRect);
if (getIsPersistent())
{
AsTexture tmpTexture = mActiveTexture;
mActiveTexture = mBufferTexture;
mBufferTexture = tmpTexture;
mHelperImage.setTexture(mBufferTexture);
}
mSupport.setRenderTarget(mActiveTexture);
mSupport.clear();
if (getIsPersistent() && mBufferReady)
{
mHelperImage.render(mSupport, 1.0f);
}
else
{
mBufferReady = true;
}
try
{
mDrawing = true;
if (drawingBlock != null)
{
drawingBlock();
}
}
finally
{
mDrawing = false;
mSupport.finishQuadBatch();
mSupport.nextFrame();
mSupport.setRenderTarget(null);
context.setScissorRectangle(null);
}
}
public static AsTexture fromBitmapData(AsBitmapData data, bool generateMipMaps, bool optimizeForRenderTexture, float scale)
{
int origWidth = data.getWidth();
int origHeight = data.getHeight();
int legalWidth = AsGlobal.getNextPowerOfTwo(origWidth);
int legalHeight = AsGlobal.getNextPowerOfTwo(origHeight);
AsContext3D context = AsStarling.getContext();
AsBitmapData potData = null;
if (context == null)
{
throw new AsMissingContextError();
}
bc.flash.display3D.textures.AsTexture nativeTexture = context.createTexture(legalWidth, legalHeight, AsContext3DTextureFormat.BGRA, optimizeForRenderTexture);
if (legalWidth > origWidth || legalHeight > origHeight)
{
potData = new AsBitmapData(legalWidth, legalHeight, true, 0);
potData.copyPixels(data, data.getRect(), sOrigin);
data = potData;
}
uploadBitmapData(nativeTexture, data, generateMipMaps);
AsConcreteTexture concreteTexture = new AsConcreteTexture(nativeTexture, AsContext3DTextureFormat.BGRA, legalWidth, legalHeight, generateMipMaps, true, optimizeForRenderTexture, scale);
if (AsStarling.getHandleLostContext())
{
concreteTexture.restoreOnLostContext(data);
}
else
{
if (potData != null)
{
potData.dispose();
}
}
if (origWidth == legalWidth && origHeight == legalHeight)
{
return(concreteTexture);
}
else
{
return(new AsSubTexture(concreteTexture, new AsRectangle(0, 0, origWidth / scale, origHeight / scale), true));
}
}
public static AsTexture fromAtfData(AsByteArray data, float scale)
{
AsContext3D context = AsStarling.getContext();
if (context == null)
{
throw new AsMissingContextError();
}
AsAtfData atfData = new AsAtfData(data);
bc.flash.display3D.textures.AsTexture nativeTexture = context.createTexture(atfData.getWidth(), atfData.getHeight(), atfData.getFormat(), false);
uploadAtfData(nativeTexture, data);
AsConcreteTexture concreteTexture = new AsConcreteTexture(nativeTexture, atfData.getFormat(), atfData.getWidth(), atfData.getHeight(), atfData.getNumTextures() > 1, false, false, scale);
if (AsStarling.getHandleLostContext())
{
concreteTexture.restoreOnLostContext(atfData);
}
return(concreteTexture);
}
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 void onContextCreated(AsEvent _event)
{
AsContext3D context = AsStarling.getContext();
AsBitmapData bitmapData = mData as AsBitmapData;
AsAtfData atfData = mData as AsAtfData;
bc.flash.display3D.textures.AsTexture nativeTexture = null;
if (bitmapData != null)
{
nativeTexture = context.createTexture(mWidth, mHeight, AsContext3DTextureFormat.BGRA, mOptimizedForRenderTexture);
AsTexture.uploadBitmapData(nativeTexture, bitmapData, mMipMapping);
}
else
{
if (atfData != null)
{
nativeTexture = context.createTexture(atfData.getWidth(), atfData.getHeight(), atfData.getFormat(), mOptimizedForRenderTexture);
AsTexture.uploadAtfData(nativeTexture, atfData.getData());
}
}
mBase = nativeTexture;
}
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);
}
}