/// <summary>
/// Applies the filter on a certain display object, rendering the output into the current render
/// target. This method is called automatically by Sparrow's rendering system for the object the
/// filter is attached to.
/// </summary>
public void RenderObject(DisplayObject obj, RenderSupport support)
{
// bottom layer
if (Mode == FragmentFilterMode.Above)
{
obj.Render(support);
}
// center layer
if (_cacheRequested)
{
_cacheRequested = false;
_cache = RenderPasses(obj, support, true);
DisposePassTextures();
}
if (_cache != null)
{
_cache.Render(support);
}
else
{
RenderPasses(obj, support, false);
}
// top layer
if (Mode == FragmentFilterMode.Below)
{
obj.Render(support);
}
}
public BoxDrawNode(DrawInfo drawInfo, Game game, Quad screenSpaceDrawQuad, QuadBatch <Vertex2d> batch)
: base(drawInfo)
{
this.game = game;
this.screenSpaceDrawQuad = screenSpaceDrawQuad;
this.batch = batch;
}
private void startBatch(bool allowRecycle = false)
{
if (hasBegun && !allowRecycle)
{
return;
}
endBatch();
int amountQuads = OsuMathHelper.Clamp(SpriteList.Count, 1, 100);
if (SpriteBatch == null || SpriteBatch.Size < amountQuads)
{
for (int i = 0; i < SpriteBatches.Length; i++)
{
SpriteBatches[i] = new QuadBatch <TexturedVertex2d>(amountQuads * 2, 500);
}
}
if (currentBlend == SpriteBlendMode.Additive)
{
OsuGlControl.SetBlend(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.One);
}
else
{
OsuGlControl.SetBlend(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
}
hasBegun = true;
Current = this;
NativeText.ScaleModifier = Scale;
}
public BufferedContainerDrawNode(DrawInfo drawInfo, FrameBuffer frameBuffer, Quad screenSpaceDrawQuad, QuadBatch <TexturedVertex2d> batch, List <RenderbufferInternalFormat> formats)
: base(drawInfo)
{
this.frameBuffer = frameBuffer;
this.screenSpaceDrawQuad = screenSpaceDrawQuad;
this.batch = batch;
this.formats = new List <RenderbufferInternalFormat>(formats);
}
// C O N S T R U C T
public VelcroChain(World worldSys, QuadBatch qbatch)
{
world = worldSys;
quadBatch = qbatch;
bods = new List <Body>();
joints = new List <WeldJoint>();
vecs = new List <Vector2>();
}
/// <summary>
/// Clears all vertex and index buffers, releasing the associated memory. Useful in low-memory
/// situations. Don't call from within a render method!
/// </summary>
public void PurgeBuffers()
{
_quadBatches.Clear();
_quadBatchTop = new QuadBatch();
_quadBatches.Add(_quadBatchTop);
_quadBatchIndex = 0;
_quadBatchSize = 1;
}
public override void ApplyState()
{
base.ApplyState();
skeleton = Source.Skeleton;
drawQuad = Source.ScreenSpaceDrawQuad;
vertexBatch = new QuadBatch <TexturedVertex2D>(skeleton.BoneCount * 6, 1);
}
/// <summary>
/// Resets the render state stack to the default.
/// </summary>
public void NextFrame()
{
_clipRectStackSize = 0;
_stateStackIndex = 0;
_quadBatchIndex = 0;
_numDrawCalls = 0;
_quadBatchTop = _quadBatches[0];
_stateStackTop = _stateStack[0];
}
public override void DrawQuad(Quad vertexQuad, RectangleF?textureRect, ColourInfo drawColour, Action <TexturedVertex2D> vertexAction = null, Vector2?inflationPercentage = null, Vector2?blendRangeOverride = null)
{
if (IsDisposed)
{
throw new ObjectDisposedException(ToString(), "Can not draw a quad with a disposed texture.");
}
RectangleF texRect = GetTextureRect(textureRect);
Vector2 inflationAmount = inflationPercentage.HasValue ? new Vector2(inflationPercentage.Value.X * texRect.Width, inflationPercentage.Value.Y * texRect.Height) : Vector2.Zero;
RectangleF inflatedTexRect = texRect.Inflate(inflationAmount);
Vector2 blendRange = blendRangeOverride ?? inflationAmount;
if (vertexAction == null)
{
if (quadBatch == null)
{
quadBatch = new QuadBatch <TexturedVertex2D>(512, 128);
}
vertexAction = quadBatch.Add;
}
vertexAction(new TexturedVertex2D
{
Position = vertexQuad.BottomLeft,
TexturePosition = new Vector2(inflatedTexRect.Left, inflatedTexRect.Bottom),
TextureRect = new Vector4(texRect.Left, texRect.Top, texRect.Right, texRect.Bottom),
BlendRange = blendRange,
Colour = drawColour.BottomLeft.Linear,
});
vertexAction(new TexturedVertex2D
{
Position = vertexQuad.BottomRight,
TexturePosition = new Vector2(inflatedTexRect.Right, inflatedTexRect.Bottom),
TextureRect = new Vector4(texRect.Left, texRect.Top, texRect.Right, texRect.Bottom),
BlendRange = blendRange,
Colour = drawColour.BottomRight.Linear,
});
vertexAction(new TexturedVertex2D
{
Position = vertexQuad.TopRight,
TexturePosition = new Vector2(inflatedTexRect.Right, inflatedTexRect.Top),
TextureRect = new Vector4(texRect.Left, texRect.Top, texRect.Right, texRect.Bottom),
BlendRange = blendRange,
Colour = drawColour.TopRight.Linear,
});
vertexAction(new TexturedVertex2D
{
Position = vertexQuad.TopLeft,
TexturePosition = new Vector2(inflatedTexRect.Left, inflatedTexRect.Top),
TextureRect = new Vector4(texRect.Left, texRect.Top, texRect.Right, texRect.Bottom),
BlendRange = blendRange,
Colour = drawColour.TopLeft.Linear,
});
FrameStatistics.Increment(StatisticsCounterType.KiloPixels, (long)vertexQuad.ConservativeArea);
}
private void updateQuadBatch()
{
if (Children == null)
{
return;
}
if (quadBatch == null && mayHaveOwnVertexBatch(sourceChildrenCount))
{
quadBatch = new QuadBatch <TexturedVertex2D>(100, 1000);
}
}
static TextureGLSingle()
{
QuadBatch <TexturedVertex2D> quadBatch = new QuadBatch <TexturedVertex2D>(512, 128);
default_quad_action = quadBatch.AddAction;
// We multiply the size param by 3 such that the amount of vertices is a multiple of the amount of vertices
// per primitive (triangles in this case). Otherwise overflowing the batch will result in wrong
// grouping of vertices into primitives.
LinearBatch <TexturedVertex2D> triangleBatch = new LinearBatch <TexturedVertex2D>(512 * 3, 128, PrimitiveType.Triangles);
default_triangle_action = triangleBatch.AddAction;
}
protected override unsafe void OnLoad(EventArgs e)
{
LoadTex();
var green = new Texture("green.png");
var red = new Texture("red.png");
{
batch = new QuadBatch <SpriteProgram, SpriteData, SpriteVertex>(4);
batch.Shader.Make(new Vector2(800, 800), new Vector2(338, 338), green, red);
batch.AddQuad(new SpriteData(new Rectangle(new Point(0, 0), new Size(200, 200)), new Rectangle(new Point(0, 0), new Size(200, 200))));
batch.AddQuad(new SpriteData(new Rectangle(new Point(300, 0), new Size(200, 200)), new Rectangle(new Point(100, 100), new Size(200, 200))));
batch.UpdateGpu();
}
{
batch2 = new QuadBatch <SpriteProgram, SpriteData, SpriteVertex>(4);
batch2.Shader.Make(new Vector2(800, 800), new Vector2(338, 338), red, green);
batch2.AddQuad(new SpriteData(new Rectangle(new Point(0, 300), new Size(200, 200)), new Rectangle(new Point(0, 0), new Size(200, 200))));
batch2.AddQuad(new SpriteData(new Rectangle(new Point(300, 300), new Size(200, 200)), new Rectangle(new Point(100, 100), new Size(200, 200))));
batch2.UpdateGpu();
}
watch.Start();
// random final setup
{
//var x = GLFW.SetMouseButtonCallback;
VSync = VSyncMode.Adaptive;
GL.FrontFace(FrontFaceDirection.Cw);
GL.PolygonMode(MaterialFace.Back, PolygonMode.Line); // make draw with lines if drawing backs
//GL.ClearColor(0.0f, 0.0f, 1.0f, 0.0f); // set clear color
}
int total = 0;
for (int currentNumber = 1; currentNumber < 1000; currentNumber++)
{
int iMod3 = currentNumber % 3;
int iMod5 = currentNumber % 5;
bool isDivisibleBy3 = iMod3 == 0;
bool isDivisibleBy5 = iMod5 == 0;
if (isDivisibleBy3 || isDivisibleBy5)
{
total += currentNumber;
}
}
base.OnLoad(e);
transform = Matrix4.CreateTranslation(new Vector3(100, 10, 0));
}
// I N I T
protected override void Initialize()
{
gpu = GraphicsDevice;
spriteBatch = new SpriteBatch(GraphicsDevice);
quadBatch = new QuadBatch(Content, gpu, "QuadEffect", "", null, null); // ( if using a rendertarget for most rendering - change null to its resolution )
pixel = new Rectangle(382, 0, 1, 1); quadBatch.PIXEL = pixel; // need this for line drawing to work in quadbatch
gras1 = new Rectangle(12, 144, 28, 82); // fixed these since last time
gras2 = new Rectangle(80, 144, 28, 82); // fixed these since last time
gras3 = new Rectangle(142, 144, 28, 82); // fixed these since last time
BigGrass = new Rectangle(0, 0, 380, 122);
world = new World(new Vector2(0f, 9.8f)); // world physics sim (provide gravity direction)
player_body = BodyFactory.CreateCircle(world, con.ToSimUnits(8.0f), 1.0f);
player_body.Position = con.ToSimUnits(400, 10);
player_body.BodyType = BodyType.Dynamic; // moves
player_body.Mass = 0.4f;
player_body.Restitution = 0.2f; // bounciness
player_body.Friction = 0.4f; // grip
player_body.CollisionCategories = Category.Cat1; player_body.CollidesWith = Category.All;
player_body.FixedRotation = false;
// attach collider_body to mouse:
mouse_joint = JointFactory.CreateFixedMouseJoint(world, player_body, player_body.Position);
mouse_joint.MaxForce = 500.0f;
// 大きな 草
big_grass_body = BodyFactory.CreateRectangle(world, con.ToSimUnits(BigGrass.Width * 0.88f), con.ToSimUnits(BigGrass.Height * 0.6f), 1.0f);
big_grass_body.Position = con.ToSimUnits(300 + BigGrass.Width / 2f - 10, 600 + BigGrass.Height / 2f);
big_grass_body.BodyType = BodyType.Static;
big_grass_body.Restitution = 0.2f; // bounciness
big_grass_body.Friction = 0.8f; // surface grip
big_grass_body.Mass = 1.0f;
big_grass_body.CollisionCategories = Category.Cat2;
big_grass_body.CollidesWith = Category.Cat1;
// DYNAMIC GRASS (BOTTOM PART):
grassChain = new VelcroChain[3];
grassChain[0] = new VelcroChain(world, quadBatch);
grassChain[0].MakeGrass(gras1.Width * 0.5f, gras1.Height, new Vector2(350, 600), num_divisions: 3, baseBody: big_grass_body, noGravity: false);
grassChain[1] = new VelcroChain(world, quadBatch);
grassChain[1].MakeGrass(gras1.Width * 0.5f, gras1.Height, new Vector2(380, 600), num_divisions: 3, baseBody: big_grass_body, noGravity: false);
grassChain[2] = new VelcroChain(world, quadBatch);
grassChain[2].MakeGrass(gras1.Width * 0.5f, gras1.Height, new Vector2(410, 600), num_divisions: 3, baseBody: big_grass_body, noGravity: false);
base.Initialize();
}
// C O N S T R U C T O R
public Text(QuadBatch Quad, int ScreenWidth, int ScreenHeight, Input Inp, Rectangle?PixelRect)
{
pixel = new Rectangle(0, 0, 1, 1); if (PixelRect.HasValue)
{
pixel = PixelRect.Value;
}
swidth = ScreenWidth; sheight = ScreenHeight;
center = new Vector2(swidth / 2, sheight / 2);
inp = Inp;
quad = Quad;
color = reg_color;
Vector2 font_size = new Vector2(quad.Average_Width, quad.text_v_space);
last_letter_x = last_letter_y = 0; letter_width = (int)font_size.X; letter_height = (int)font_size.Y;
}
private void updateQuadBatch()
{
if (Children == null)
{
return;
}
// This logic got roughly copied from the old osu! code base. These constants seem to have worked well so far.
int clampedAmountChildren = MathHelper.Clamp(Children.Count, 1, 1000);
if (mayHaveOwnVertexBatch(clampedAmountChildren) && (quadBatch == null || quadBatch.Size < clampedAmountChildren))
{
quadBatch = new QuadBatch <TexturedVertex2D>(clampedAmountChildren * 2, 500);
}
}
public override void DrawQuad(Quad vertexQuad, RectangleF?textureRect, ColourInfo drawColour, Action <TexturedVertex2D> vertexAction = null, Vector2?inflationPercentage = null)
{
Debug.Assert(!isDisposed);
RectangleF texRect = GetTextureRect(textureRect);
if (inflationPercentage.HasValue)
{
texRect = texRect.Inflate(new Vector2(inflationPercentage.Value.X * texRect.Width, inflationPercentage.Value.Y * texRect.Height));
}
if (vertexAction == null)
{
if (quadBatch == null)
{
quadBatch = new QuadBatch <TexturedVertex2D>(512, 128);
}
vertexAction = quadBatch.Add;
}
vertexAction(new TexturedVertex2D
{
Position = vertexQuad.BottomLeft,
TexturePosition = new Vector2(texRect.Left, texRect.Bottom),
Colour = drawColour.BottomLeft.Linear,
});
vertexAction(new TexturedVertex2D
{
Position = vertexQuad.BottomRight,
TexturePosition = new Vector2(texRect.Right, texRect.Bottom),
Colour = drawColour.BottomRight.Linear,
});
vertexAction(new TexturedVertex2D
{
Position = vertexQuad.TopRight,
TexturePosition = new Vector2(texRect.Right, texRect.Top),
Colour = drawColour.TopRight.Linear,
});
vertexAction(new TexturedVertex2D
{
Position = vertexQuad.TopLeft,
TexturePosition = new Vector2(texRect.Left, texRect.Top),
Colour = drawColour.TopLeft.Linear,
});
FrameStatistics.Increment(StatisticsCounterType.KiloPixels, (long)vertexQuad.ConservativeArea);
}
/// <summary>
/// Renders the current quad batch and resets it.
/// </summary>
public void FinishQuadBatch()
{
if (_quadBatchTop.NumQuads != 0)
{
_quadBatchTop.Render(_projectionMatrix);
_quadBatchTop.Reset();
if (_quadBatchSize == _quadBatchIndex + 1)
{
_quadBatches.Add(new QuadBatch());
_quadBatchSize++;
}
_numDrawCalls++;
_quadBatchTop = _quadBatches[++_quadBatchIndex];
}
}
public void lerpGeometry(int index, int count, QuadBatch target, float factor)
{
for (int i = 0; i < count; i++)
{
int vidx = (index + i) * 4;
Vector3 bl = vertexBatch.vertices[vidx + 0];
Vector3 tl = vertexBatch.vertices[vidx + 1];
Vector3 tr = vertexBatch.vertices[vidx + 2];
Vector3 br = vertexBatch.vertices[vidx + 3];
Vector3 tbl = target.vertexBatch.vertices[vidx + 0];
Vector3 ttl = target.vertexBatch.vertices[vidx + 1];
Vector3 ttr = target.vertexBatch.vertices[vidx + 2];
Vector3 tbr = target.vertexBatch.vertices[vidx + 3];
vertexBatch.vertices[vidx + 0] = Vector3.Lerp(bl, tbl, factor);
vertexBatch.vertices[vidx + 1] = Vector3.Lerp(tl, ttl, factor);
vertexBatch.vertices[vidx + 2] = Vector3.Lerp(tr, ttr, factor);
vertexBatch.vertices[vidx + 3] = Vector3.Lerp(br, tbr, factor);
}
}
public TextField(float width, float height, string text = "", string fontName = "mini", float fontSize = 14, uint color = 0x0)
{
_text = text;
_fontSize = fontSize;
_color = color;
_hAlign = HAlign.Center;
_vAlign = VAlign.Center;
_autoScale = false;
_kerning = true;
_requiresRedraw = true;
FontName = fontName;
_hitArea = new Quad(width, height);
_hitArea.Alpha = 0.0f;
AddChild(_hitArea);
_contents = new QuadBatch();
_contents.Touchable = false;
AddChild(_contents);
//[self addEventListener:@selector(onFlatten:) atObject:self forType:SPEventTypeFlatten];
}
//--------
// I N I T
//--------
protected override void Initialize()
{
#region // SETUP SPRITEBATCH AND GET TRUE DISPLAY
spriteBatch = new SpriteBatch(GraphicsDevice); pp = GraphicsDevice.PresentationParameters; SurfaceFormat format = pp.BackBufferFormat;
MainTarget = new RenderTarget2D(GraphicsDevice, SCREENWIDTH, SCREENHEIGHT);
screenW = MainTarget.Width; screenH = MainTarget.Height;
desktopRect = new Rectangle(0, 0, pp.BackBufferWidth, pp.BackBufferHeight); screenRect = new Rectangle(0, 0, screenW, screenH);
quadBatch = new QuadBatch(Content, GraphicsDevice, "QuadEffect", "FontTexture", screenW, screenH); // setup distortable quad class (like spriteBatch)
pixel = new Rectangle(0, 0, 1, 1); quadBatch.PIXEL = pixel;
rnd = new Random(); inp = new Input(pp, MainTarget);
text = new Text(quadBatch, screenW, screenH, inp, pixel); text.Size = 0.5f;
#endregion
tailRec = new Rectangle(195, 130, 188, 44);
// M A K E B O N E S : : :
bones = new TailBone[5];
for (int i = 0; i < bones.Length; i++)
{
bones[i] = new TailBone(tail_size);
}
base.Initialize();
}
public override void Draw()
{
if (Texture == null)
{
return;
}
// For billboarding
Shader.SetGlobalProperty("g_InverseViewMatrix", InverseViewMatrix);
// Taken from DrawNode3D, since we don't need the world transform for particle systems
GLWrapper.SetBlend(Blending);
Shader.Bind();
// Force create a separate batch so we can use instanced rendering
if (particleInstancedBatch == null)
{
particleInstancedBatch = new QuadBatch <TexturedVertex2D>(TexturedVertex2D.Stride * 4, 1);
}
var colourInfo = new ColourInfo {
Colour = Color4.White
};
Texture.DrawQuad(new Quad(-0.5f, -0.5f, 1.0f, 1.0f), colourInfo, vertexAction: v => particleInstancedBatch.Add(v));
// Set GPU buffer data
Buffer.SetData(BufferData);
Buffer.Bind();
// Render instanced
particleInstancedBatch.DrawInstanced(InstanceCount);
Shader.Unbind();
}
public RenderSupport()
{
_projectionMatrix = Matrix.Create();
_mvpMatrix = Matrix.Create();
_stateStack = new List <RenderState> {
new RenderState()
};
_stateStackIndex = 0;
_stateStackSize = 1;
_stateStackTop = _stateStack[0];
_quadBatches = new List <QuadBatch> {
new QuadBatch()
};
_quadBatchIndex = 0;
_quadBatchSize = 1;
_quadBatchTop = _quadBatches[0];
_clipRectStack = new List <Rectangle>();
_clipRectStackSize = 0;
SetupOrthographicProjection(0, 320, 0, 480);
}
/// <summary>
/// Draws text into a quad batch.
/// </summary>
public void FillQuadBatch(QuadBatch quadBatch, float width, float height, string text, float size, uint color, HAlign hAlign, VAlign vAlign, bool autoScale, bool kerning)
{
List <CharLocation> charLocations = ArrangeCharsInArea(width, height, text, size, hAlign, vAlign, autoScale, kerning);
_helperImage.Color = color;
if (charLocations.Count > MAX_TEXT_CHAR_COUNT)
{
throw new InvalidDataException(string.Format("Bitmap font text is limited to {0} characters", MAX_TEXT_CHAR_COUNT));
}
CharLocation charLocation;
for (int i = 0; i < charLocations.Count; i++)
{
charLocation = charLocations[i];
_helperImage.Texture = charLocation.BitmapChar.Texture;
_helperImage.X = charLocation.X;
_helperImage.Y = charLocation.Y;
_helperImage.ScaleX = _helperImage.ScaleY = charLocation.Scale;
_helperImage.ReadjustSize();
quadBatch.AddQuad(_helperImage);
}
}
private void DisposeCache()
{
_cache = null;
}
public void Set(QuadBatch qb)
{
vertexBatch = qb.vertexBatch.Duplicate();
}
static TextureGLSingle()
{
QuadBatch <TexturedVertex2D> quadBatch = new QuadBatch <TexturedVertex2D>(512, 128);
default_quad_action = quadBatch.AddAction;
}
public override void Load()
{
m_ImGuiDriver = new ImGuiDriver();
m_ImGuiDriver.Initalise(GraphicsDevice, m_ResourceManager);
camera = new GameCamera(new Vector3(40, 40, 40), new Vector3(80, 80, 0), 55, -20);
m_QuadBatch = new QuadBatch();
var cubeShader = m_ResourceManager.LoadShaderFromFile("v.cube.glsl", "f.cube.glsl");
var skyboxShader = m_ResourceManager.LoadShaderFromFile("v.skybox.glsl", "f.skybox.glsl");
var terrainShader = m_ResourceManager.LoadShaderFromFile("v.terrain.glsl", "f.terrain.glsl");
var waterShader = m_ResourceManager.LoadShaderFromFile("v.water.glsl", "f.water.glsl");
// Load Textures
{
m_AwesomeFace = m_ResourceManager.LoadTexture2d("awesomeface.png");
m_Texture = m_ResourceManager.LoadTexture2d("texture1.png");
//m_Default = m_ResourceManager.LoadTexture2d("default.png");
}
// Load Terrain
{
var heightMapData = HeightMapData.LoadHeightmapData("Resources/Textures/Heightmaps/1.png");
var model = ModelLoader.CreateTerrain(heightMapData);
var terrainVAO = m_ResourceManager.LoadVAO(model.Verts, model.Indicies, VertexPositionColorTextureNormal.Stride, VertexPositionColorTextureNormal.AttributeLengths, VertexPositionColorTextureNormal.AttributeOffsets);
m_TerrainRenderObject = new Terrain(terrainShader.ShaderProgramId, terrainVAO.VaoId, terrainVAO.VertexCount);
}
// Create Water
{
var model = ModelLoader.CreatePlane(1024, 1024, 12.2f);
var waterVAO = m_ResourceManager.LoadVAO(model.Verts, model.Indicies, VertexPositionColorTextureNormal.Stride, VertexPositionColorTextureNormal.AttributeLengths, VertexPositionColorTextureNormal.AttributeOffsets);
m_WaterRenderObject = new Water(waterShader.ShaderProgramId, waterVAO.VaoId, waterVAO.VertexCount);
}
// Create Bunny
{
var bunnyVerts = ModelLoader.LoadObj("Resources/Models/bunny.obj");
var bunnyVAO = m_ResourceManager.LoadVAO(bunnyVerts.Verts, bunnyVerts.Indicies, VertexPositionColorTextureNormal.Stride, VertexPositionColorTextureNormal.AttributeLengths, VertexPositionColorTextureNormal.AttributeOffsets);
m_BunnyRenderObject = new Bunny(terrainShader.ShaderProgramId, bunnyVAO.VaoId, bunnyVAO.VertexCount);
}
// Create Cube
{
Maploader mp = new Maploader();
mp.Load();
var verts = Geometry.CreateCube();
var m_CubeVAO = m_ResourceManager.LoadNonIndexedVAO(verts, VertexPositionColorTexture.Stride, VertexPositionColorTexture.AttributeLengths, VertexPositionColorTexture.AttributeOffsets);
m_Cube = new Cube[Maploader.width * Maploader.height];
for (int i = 0; i < Maploader.width * Maploader.height; i++)
{
m_Cube[i] = new Cube(cubeShader.ShaderProgramId, m_CubeVAO.VaoId, m_CubeVAO.VertexCount);
m_Cube[i].i = i;
m_Cube[i].TextureIdA = m_AwesomeFace.TextureId;
m_Cube[i].TextureIdB = m_Texture.TextureId;
}
int k = 0;
for (int i = 0; i < Maploader.width; i++)
{
for (int j = 0; j < Maploader.height; j++)
{
var height = (float)mp.cubes[i, j];
height /= 2.0f;
if (height < 0)
{
height = -100; // Temp
}
height += 20;
m_Cube[k].Position = new Vector3(i, height, j);
k++;
}
}
}
// Create Skyubox
{
var verts = Geometry.CreateSkyBoxVerticies();
var skyboxVAO = m_ResourceManager.LoadNonIndexedVAO(verts, VertexPosition.Stride, VertexPosition.AttributeLengths, VertexPosition.AttributeOffsets);
var cubeMap = m_ResourceManager.LoadCubeMap("Skybox/front.png", "Skybox/back.png", "Skybox/bottom.png", "Skybox/top.png", "Skybox/left.png", "Skybox/right.png");
m_SkyBoxRenderObject = new SkyBox(skyboxShader.ShaderProgramId, skyboxVAO.VaoId, skyboxVAO.VertexCount, cubeMap.TextureId);
}
// Load Font
{
m_FontAriel = m_ResourceManager.LoadTextureFont("ariel.fnt");
}
renderTarget = RenderTarget.Create(GameWindow.ScreenWidth, GameWindow.ScreenHeight); // TODO This should be the size of the screen
quad = new ScreenSpaceQuad();
quad.Create();
}
public RenderContext()
{
QuadBatch = new QuadBatch();
PrimitiveBatch = new PrimitiveBatch();
TextureFill = new TextureFill();
}
//-----------------------------------------------------------------------------
// Method: GetQuadDefinition()
// Desc: Returns a reference to a QuadDefinition object from the specified
// quad batch, or null if none are left
public BatchedQuadDef GetQuadDefinition( QuadBatch batch )
{
return PrimitiveQuadBatch.GetQuadDef( m_quadBatches[(int)batch] );
}
public void lerpGeometry(QuadBatch target, float factor)
{
lerpGeometry(0, Count, target, factor);
}
private QuadBatch RenderPasses(DisplayObject obj, RenderSupport support, bool intoCache)
{
Texture cacheTexture = null;
Stage stage = obj.Stage;
float scale = Resolution;
if (stage == null)
{
throw new InvalidOperationException("Filtered object must be on the stage.");
}
// the bounds of the object in stage coordinates
Rectangle boundsPOT;
Rectangle bounds;
CalcBounds(obj, stage, scale, !intoCache, out bounds, out boundsPOT);
if (bounds.IsEmpty())
{
DisposePassTextures();
return(intoCache ? new QuadBatch() : null);
}
UpdateBuffers(boundsPOT);
UpdatePassTextures((int)boundsPOT.Width, (int)boundsPOT.Height, scale);
support.FinishQuadBatch();
support.AddDrawCalls(NumPasses);
support.PushState(Matrix.Create(), 1.0f, BlendMode.AUTO);
// save original projection matrix and render target
_projMatrix.CopyFromMatrix(support.ProjectionMatrix);
Texture previousRenderTarget = support.RenderTarget;
// use cache?
if (intoCache)
{
cacheTexture = CreateTexture((int)boundsPOT.Width, (int)boundsPOT.Height, scale);
}
// draw the original object into a texture
support.RenderTarget = _passTextures[0];
SparrowSharpApp.Context.ScissorBox = null; // we want the entire texture cleared
support.Clear();
support.BlendMode = BlendMode.NORMAL;
support.SetupOrthographicProjection(boundsPOT.Left, boundsPOT.Right, boundsPOT.Bottom, boundsPOT.Top);
obj.Render(support);
support.FinishQuadBatch();
// prepare drawing of actual filter passes
support.ApplyBlendMode(true);
support.ModelViewMatrix.Identity();
support.PushClipRect(bounds);
GL.BindBuffer(BufferTarget.ArrayBuffer, _vertexBufferName);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, _indexBufferName);
GL.EnableVertexAttribArray(VertexPosID);
GL.VertexAttribPointer(VertexPosID, 2, VertexAttribPointerType.Float, false, Vertex.SIZE, (IntPtr)Vertex.POSITION_OFFSET);
GL.EnableVertexAttribArray(TexCoordsID);
GL.VertexAttribPointer(TexCoordsID, 2, VertexAttribPointerType.Float, false, Vertex.SIZE, (IntPtr)Vertex.TEXTURE_OFFSET);
// draw all passes
for (int i = 0; i < NumPasses; ++i)
{
if (i < NumPasses - 1)
{ // intermediate pass
// draw into pass texture
support.RenderTarget = PassTextureForPass(i + 1);
support.Clear();
}
else
{ // final pass
if (intoCache)
{
// draw into cache texture
support.RenderTarget = cacheTexture;
support.Clear();
}
else
{
// draw into back buffer, at original (stage) coordinates
support.RenderTarget = previousRenderTarget;
support.ProjectionMatrix = _projMatrix;
support.ModelViewMatrix.Translate(OffsetX, OffsetY);
support.BlendMode = obj.BlendMode;
support.ApplyBlendMode(true);
}
}
Texture passTexture = PassTextureForPass(i);
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, passTexture.Name);
ActivateWithPass(i, passTexture, support.MvpMatrix);
GL.DrawElements(BeginMode.Triangles, 6, DrawElementsType.UnsignedShort, IntPtr.Zero);
DeactivateWithPass(i, passTexture);
}
GL.DisableVertexAttribArray(VertexPosID);
GL.DisableVertexAttribArray(TexCoordsID);
support.PopState();
support.PopClipRect();
QuadBatch cache = null;
if (intoCache)
{
// restore support settings
support.RenderTarget = previousRenderTarget;
support.ProjectionMatrix = _projMatrix;
// Create an image containing the cache. To have a display object that contains
// the filter output in object coordinates, we wrap it in a QuadBatch: that way,
// we can modify it with a transformation matrix.
cache = new QuadBatch();
Image image = new Image(cacheTexture);
Matrix matrix = stage.TransformationMatrixToSpace(obj);
// Note: the next line was originally:
// matrix.Translate (bounds.X + OffsetX, bounds.Y + OffsetY);
// this seems like a sparrow-s bug; fix is from Starling
matrix.PrependTranslation(bounds.X + OffsetX, bounds.Top + OffsetY);
cache.AddQuad(image, 1.0f, BlendMode.AUTO, matrix);
}
return(cache);
}
