YO! Nice sample! I have some problems with adding soft shadows and unable to rotate convex hull. would u be so kind as to help me?

I haven’t yet tried doing soft shadows, so I can’t help you there. As for rotating the objects…. you could probably transform each vertex manually.

Excellent sample.

Can this code be used in a commercial project?

Just what I was looking for. Great stuff.

Thanks, and keep up the good work!

Yeah, those two are the bottlenecks at the moment. I tried to think of many ways to do the shadow generation in a vertex shader, but unfortunately didn’t find a solution.

One possible solution could be replacing the usage of the alpha channel for lightmaps with the usage of the stencil buffer. This might cut down on the number of renderstates that need to be set for each light, and maybe it is faster. The idea is mainly the same. Draw the shadows and while doing that, the affected pixels are marked in the stencil buffer. And then, when drawing the light, a test is made and only unmarked pixels are written.

to clear the stencil buffer: GraphicsDevice.Clear(ClearOptions.Stencil, Color.Black, 0, 0);

By moving it to Creator’s Club Forums, it’s possible you’ll have other people look at the problem and come up with more ideas.

Rautapalli:

i have a camera that i apply to spritebatch so that i can use world coordinates for all my objects and just move the camera for movement.

(i use World1.cam.get_transformation(GraphicsDevice)); in my spriteBatch.Begin())

//I get all my hull objects from this call
World1.GatherShadows();
DrawLightmap();

graphics.GraphicsDevice.Clear(Color.White);

// TODO: This is where i do my map drawing spriteBatch.Begin(SpriteBlendMode.None, SpriteSortMode.Immediate, SaveStateMode.SaveState, World1.cam.get_transformation(GraphicsDevice)); /*Send the variable that has your graphic device here*/

spriteBatch.End();

//Now draw all shadows

spriteBatch.Begin(SpriteBlendMode.None, SpriteSortMode.Immediate, SaveStateMode.SaveState, World1.cam.get_transformation(GraphicsDevice)); /*Send the variable that has your graphic device here*/

//World1.Worldobjects are all my stored hull objects
foreach (ConvexHull hull in World1.Worldobjects)
{
hull.Draw(gameTime, World1.cam.get_transformation(GraphicsDevice));
}

spriteBatch.End();

//Now draw the actual light
spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate, SaveStateMode.SaveState); /*Send the variable that has your graphic device here*/

GraphicsDevice.RenderState.SourceBlend = Blend.Zero;
GraphicsDevice.RenderState.DestinationBlend = Blend.SourceColor;
GraphicsDevice.RenderState.BlendFunction = BlendFunction.Add;
spriteBatch.Draw(lightMap.GetTexture(), Vector2.Zero + new Vector2(400,300), null, Color.White, 0.0f, new Vector2(400.0f, 300.0f), 1.0f, 0, 0);

spriteBatch.End();

base.Draw(gameTime);

//———————————————————
Now notice the changes in the class. I made no changes to the light class because it takes spritebatch in its draw and if you noticed above i already used the World1.cam.get_transformation(GraphicsDevice) in the spriteBatch.Begin(….

however in the ConvexHull.cs
concentrate on 2 subs

//Draw
public void Draw(GameTime gameTime, Matrix TransformWorld)
{
GraphicsDevice device = game.GraphicsDevice;
device.RenderState.CullMode = CullMode.None;
device.RenderState.AlphaBlendEnable = false;

device.VertexDeclaration = vertexDecl;

drawingEffect.World = Matrix.CreateTranslation(position.X, position.Y, 0) * TransformWorld;
drawingEffect.Begin();

foreach (EffectPass pass in drawingEffect.CurrentTechnique.Passes)
{
pass.Begin();
device.DrawUserIndexedPrimitives(PrimitiveType.TriangleFan, vertices, 0, vertices.Length, indices, 0, vertexCount);
pass.End();

}
drawingEffect.End();
}

//DrawShadow
public void DrawShadows(LightSource lightSource, Matrix TransformWorld)
{
//compute facing of each edge, using N*L
for (int i = 0; i 0)
backFacing[i] = false;
else
backFacing[i] = true;
}

//find beginning and ending vertices which
//belong to the shadow
int startingIndex = 0;
int endingIndex = 0;
for (int i = 0; i startingIndex)
shadowVertexCount = endingIndex – startingIndex + 1;
else
shadowVertexCount = vertexCount + 1 – startingIndex + endingIndex;

shadowVertices = new VertexPositionColor[shadowVertexCount * 2];

//create a triangle strip that has the shape of the shadow
int currentIndex = startingIndex;
int svCount = 0;
while (svCount != shadowVertexCount * 2)
{
Vector3 vertexPos = vertices[currentIndex].Position + new Vector3(position, 0);

//one vertex on the hull
shadowVertices[svCount] = new VertexPositionColor();
shadowVertices[svCount].Color = Color.TransparentBlack;
shadowVertices[svCount].Position = vertexPos;

//one extruded by the light direction
shadowVertices[svCount + 1] = new VertexPositionColor();
shadowVertices[svCount + 1].Color = Color.TransparentBlack;
Vector3 L2P = vertexPos – new Vector3(lightSource.Position, 0);
L2P.Normalize();
shadowVertices[svCount + 1].Position = new Vector3(lightSource.Position, 0) + L2P * 9000;

svCount += 2;
currentIndex = (currentIndex + 1) % vertexCount;
}
Matrix NewTemp = Matrix.Identity;

//draw the shadow geometry
game.GraphicsDevice.VertexDeclaration = vertexDecl;
drawingEffect.World = TransformWorld;
drawingEffect.Begin();
drawingEffect.CurrentTechnique.Passes[0].Begin();

game.GraphicsDevice.DrawUserPrimitives(PrimitiveType.TriangleStrip, shadowVertices, 0, shadowVertexCount * 2 – 2);

drawingEffect.CurrentTechnique.Passes[0].End();
drawingEffect.End();

}

//hope this helps.

hmm well i figured it out.

within the DrawLightmap method

I moved the

foreach (ConvexHull hull in World1.Worldobjects)
{
hull.Draw(gT, World1.cam.get_transformation(GraphicsDevice));
}

right after the

foreach (ConvexHull ch in World1.Worldobjects)
{
//draw shadow
if (ch != null)
{

ch.DrawShadows(light, World1.cam.get_transformation(GraphicsDevice));

}
}

so to recap in DrawLightmap method it should look like the following:

foreach (LightSource light in lights)
{
//clear alpha to 1
ClearAlphaToOne();

//draw all shadows
//write only to the alpha channel, which sets alpha to 0
GraphicsDevice.RenderState.ColorWriteChannels = ColorWriteChannels.Alpha;
GraphicsDevice.RenderState.CullMode = CullMode.None;
GraphicsDevice.RenderState.AlphaBlendEnable = true;
GraphicsDevice.RenderState.DestinationBlend = Blend.Zero;
GraphicsDevice.RenderState.SourceBlend = Blend.One;

foreach (ConvexHull ch in World1.Worldobjects)
{
//draw shadow
if (ch != null)
{

ch.DrawShadows(light, World1.cam.get_transformation(GraphicsDevice));

}
}
foreach (ConvexHull hull in World1.Worldobjects)
{
hull.Draw(gT, World1.cam.get_transformation(GraphicsDevice));
}

GraphicsDevice.RenderState.ColorWriteChannels = ColorWriteChannels.All;

//draw the light shape
//where Alpha is 0, nothing will be written
//This is the light
spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate, SaveStateMode.SaveState, World1.cam.get_transformation(GraphicsDevice));
GraphicsDevice.RenderState.DestinationBlend = Blend.One;
GraphicsDevice.RenderState.SourceBlend = Blend.DestinationAlpha;
GraphicsDevice.RenderState.BlendFunction = BlendFunction.Add;
GraphicsDevice.RenderState.SeparateAlphaBlendEnabled = true;
light.Draw(spriteBatch);
spriteBatch.End();

}

Now this will have the hulls lit up (fully) when light touches it

If you would prefer them without light then make sure your color value is passed with an alpha of 0.

this is my line to create the object (hull)

objects = new ConvexHull(game2, Points, new Color(0,0,0,0), new Vector2(X, Y));

Well this seems to have worked for me anyway.

Sorry, me again 😛

What I want to do is only draw the cached “cutted” static lights (by cutted, I mean, the light source and removing the parts that are shadowed), as the shadows are already in the dynamic shadows’ RenderTarget2D.

Is anyone interested in a GPU based shadowing method?

Wow, thats real awsome! You also can use this for tile Based games (32×32 tiles, 800×600), and it’s still very fast!

Thank you very much!
FlySoft

Hello!

I’ve created an extremely fast (full hd ready, 100+ lights) vertex-based 2D lighting engine, optimised for both PC and the Xbox 360, running on the XNA 4.0 framework. If anyone is interested in a ready-to-use, opensource 2D engine, rather than implementing your own solution, you can check out http://Krypton.codeplex.com/ 🙂

Props to OrangyTang and Catalin!