private void Init(ResourceHandle<Image> imageHandle, float x, float y, float w, float h, Margin inMargin, float drawMarginScale = 1.0f)
{
this.imageHandle = imageHandle;
m_Margin = inMargin;
SetRect(0, x, y, m_Margin.Left, m_Margin.Top);
SetRect(1, x + m_Margin.Left, y, w - m_Margin.Left - m_Margin.Right, m_Margin.Top);
SetRect(2, (x + w) - m_Margin.Right, y, m_Margin.Right, m_Margin.Top);
SetRect(3, x, y + m_Margin.Top, m_Margin.Left, h - m_Margin.Top - m_Margin.Bottom);
SetRect(4, x + m_Margin.Left, y + m_Margin.Top, w - m_Margin.Left - m_Margin.Right,
h - m_Margin.Top - m_Margin.Bottom);
SetRect(5, (x + w) - m_Margin.Right, y + m_Margin.Top, m_Margin.Right, h - m_Margin.Top - m_Margin.Bottom - 1);
SetRect(6, x, (y + h) - m_Margin.Bottom, m_Margin.Left, m_Margin.Bottom);
SetRect(7, x + m_Margin.Left, (y + h) - m_Margin.Bottom, w - m_Margin.Left - m_Margin.Right, m_Margin.Bottom);
SetRect(8, (x + w) - m_Margin.Right, (y + h) - m_Margin.Bottom, m_Margin.Right, m_Margin.Bottom);
m_Margin.Left = (int)(m_Margin.Left*drawMarginScale);
m_Margin.Right = (int)(m_Margin.Right*drawMarginScale);
m_Margin.Top = (int)(m_Margin.Top*drawMarginScale);
m_Margin.Bottom = (int)(m_Margin.Bottom*drawMarginScale);
m_Width = w - x;
m_Height = h - y;
}
public bool TryGetGlyphImage(Font font, int codepoint, out SubTexture texture, out ResourceHandle<Material> material)
{
material = textMaterial;
var glyphId = new GlyphId(font, codepoint);
if (glyphSubTextures.TryGetValue(glyphId, out texture))
return true;
var nativeFont = font.EngineFont.Resolve();
var imageHandle = nativeFont.CreateGlyphImage(codepoint, font.Size);
if (imageHandle.Id == ResourceHandle<Resource>.Invalid)
return false;
if (!textureAtlas.AddImage(imageHandle))
{
throw new Exception("Atlas full");
}
if (!textureAtlas.GetImageSubTexture(imageHandle, out texture))
return false;
glyphSubTextures.Add(glyphId, texture);
return true;
}
public void UnregisterResource(string resourceID)
{
ArgumentUtility.CheckNotNullOrEmpty ("resourceID", resourceID);
var resourceHandle = new ResourceHandle (Guid.Parse (resourceID));
ResourceManager.RemoveResource (resourceHandle);
}
public Bordered(ResourceHandle<Image> imageHandle, float x, float y, float w, float h, Margin inMargin, float drawMarginScale = 1.0f)
: this()
{
m_Rects = new SubRect[9];
for (int i = 0; i < m_Rects.Length; i++)
{
m_Rects[i].uv = new float[4];
}
Init(imageHandle, x, y, w, h, inMargin, drawMarginScale);
}
public ResourceHandle AddResource(FileSystemInfo path)
{
ArgumentUtility.CheckNotNull ("path", path);
var resource = _resources.FirstOrDefault (p => p.Value.FullName == path.FullName);
var handle = resource.Key;
if (handle == default (ResourceHandle))
{
handle = new ResourceHandle (Guid.NewGuid());
_resources[handle] = path;
}
return handle;
}
public GlyphManager()
{
glyphSubTextures = new Dictionary<GlyphId, SubTexture>();
glyphInfos = new Dictionary<GlyphId, Glyph>();
textureAtlas = new TextureAtlas(512,PixelFormat.R8G8B8);
textMaterial = Material.Create(Allocator.GetHeap(), "TextMaterial");
var mat = textMaterial.Resolve();
mat.BackfaceCulling = false;
mat.SetBlending(BlendSource.SourceAlpha, BlendDestination.InverseSourceAlpha);
mat.SetShader("Text");
mat.SetTexture(0, textureAtlas.AtlasImageHandle);
mat.GetTextureUnit(0).WrapMode = TextureWrapMode.ClampToEdge;
}
public TerrainTile(RenderSystem rs, int col, int lat)
: base(true)
{
terrain0 = TerrainMeshManager.Instance.CreateInstance(rs, col, lat, 17);
terrain0.Touch();
//terrain1 = TerrainMeshManager.Instance.CreateInstance(rs, col, lat, 17);
//terrain1.Touch();
Transformation = terrain0.GetWeakResource().Transformation;
BoundingSphere = terrain0.GetWeakResource().BoundingSphere;
//Transformation = terrain0.GetWeakResource().Transformation;
//BoundingSphere = terrain0.GetWeakResource().BoundingSphere;
//terrain0.GetWeakResource().ObjectSpaceChanged += TerrainMesh_ObjectSpaceChanged;
//terrain1.GetWeakResource().ObjectSpaceChanged += TerrainMesh_ObjectSpaceChanged;
}
public Single(ResourceHandle<Image> imageHandle, float x, float y, float w, float h )
{
this._imageHandle = imageHandle;
float texw = imageHandle.Resolve().Width;
float texh = imageHandle.Resolve().Height;
m_uv = new float[4];
m_uv[0] = x / texw;
m_uv[1] = y / texh;
m_uv[2] = (x + w) / texw;
m_uv[3] = (y + h) / texh;
m_Width = (int) w;
m_Height = (int) h;
}
public void AddRectangle(Rectangle rect, Vector2 uv1, Vector2 uv2,
ResourceHandle<Image> imageHandle, System.Drawing.Color color)
{
BatchInfo batchInfo = GetCreateBatchInfo(imageHandle);
batchInfo.Ranges.Add((int)gb.GetNumVertices());
int top = Math.Max(rect.Bottom,rect.Top);
int bottom = Math.Max(rect.Bottom,rect.Top);
int left = rect.Left;
int right = rect.Right;
Vertex v1,v2,v3,v4;
v1.position = new Vector3(left, bottom,zcount);
v2.position = new Vector3(right, bottom,zcount);
v3.position = new Vector3(right, top,zcount);
v4.position = new Vector3(left, top,zcount);
//TODO optimize precision/usage
zcount += 0.001f;
var c = new Color(color.R/255.0f,color.G/255.0f,color.B/255.0f,color.A/255.0f);
v1.color = c;
v2.color = c;
v3.color = c;
v4.color = c;
//v1.uv = uv1;
//v2.uv = new Vector2(uv2.x, uv1.y);
//v3.uv = uv2;
//v4.uv = new Vector2(uv1.x, uv2.y);
// Vertex buffer setup
//gb.Add((uint8*)&v1,sizeof(Vertex));
//gb.Add((uint8*)&v2,sizeof(Vertex));
//gb.Add((uint8*)&v3,sizeof(Vertex));
//gb.Add((uint8*)&v4,sizeof(Vertex));
}
/// <summary>
/// Draws textured rectangle.
/// </summary>
/// <param name="t">MaterialHandle to use.</param>
/// <param name="materialHandle">Material to use.</param>
/// <param name="u1">MaterialHandle coordinate u1.</param>
/// <param name="v1">MaterialHandle coordinate v1.</param>
/// <param name="u2">MaterialHandle coordinate u2.</param>
/// <param name="v2">MaterialHandle coordinate v2.</param>
public void DrawTexturedRect(ResourceHandle<Image> imageHandle, Rectangle rect, float u1=0, float v1=0, float u2=1, float v2=1)
{
DrawTexturedRect(imageHandle, new RectangleF(rect.X, rect.Y, rect.Width, rect.Height), u1, v1, u2, v2);
}
/// <summary>
/// Gets pixel color of a specified texture, returning default if otherwise failed. Slow.
/// </summary>
/// <param name="materialHandle"> </param>
/// <param name="x">X.</param>
/// <param name="y">Y.</param>
/// <param name="defaultColor">Color to return on failure.</param>
/// <returns>Pixel color.</returns>
public virtual Color PixelColor(ResourceHandle<Image> imagelHandle, uint x, uint y, Color defaultColor)
{
return defaultColor;
}
protected void AddQuad(IntPtr v1, IntPtr v2, IntPtr v3, IntPtr v4, uint structSize, ResourceHandle <Image> imageHandle)
{
var materialHandle = GetCreateMaterial(imageHandle);
AddQuad(v1, v2, v3, v4, structSize, materialHandle);
}
public void SetImage(ResourceHandle<Image> imageHandle)
{
this.imageHandle = imageHandle;
SizeToContents();
}
public override void InitalizeGraphics(RenderSystem rs)
{
ForestInfo info;
info.Latitude = Latitude;
info.Longitude = Longitude;
info.Radius = Radius;
info.Amount = CurrentAmount;
//info.Plants = TreeModelLibrary.Instance.Get(0);
model = TreeBatchModelManager.Instance.CreateInstance(rs, info);
model.Touch();
Transformation = model.GetWeakResource().Transformation;
BoundingSphere = model.GetWeakResource().BoundingVolume;
sound = SoundManager.Instance.MakeSoundObjcet("forest", null, BoundingSphere.Radius);
sound.Position = BoundingSphere.Center;
{
float radLng = MathEx.Degree2Radian(Longitude);
float radLat = MathEx.Degree2Radian(Latitude);
float alt = TerrainData.Instance.QueryHeight(radLng, radLat);
stdPosition = PlanetEarth.GetPosition(radLng, radLat, alt * TerrainMeshManager.PostHeightScale + PlanetEarth.PlanetRadius);
stdTransform = PlanetEarth.GetOrientation(radLng, radLat);
stdTransform.TranslationValue = stdPosition;
selectionSphere.Center = stdPosition;
selectionSphere.Radius = 200;
}
FileLocation fl = FileSystem.Instance.Locate("wooden_board_green.mesh", GameFileLocs.Model);
board = new Model(ModelManager.Instance.CreateInstance(rs, fl));
board.CurrentAnimation.Clear();
board.CurrentAnimation.Add(
new NoAnimaionPlayer(
Matrix.Translation(0, 0, 25) *
Matrix.Scaling(2.7f, 2.7f, 2.7f) *
Matrix.RotationX(-MathEx.PiOver2) *
Matrix.RotationY((-MathEx.PIf * 7.0f) / 8.0f)
));
}
protected abstract ResourceHandle<Material> CreateMaterial(ResourceHandle<Image> imageHandle);
public HavokNavmeshCostGraphProvider(ResourceHandle <HavokNavmeshResource> handle)
{
_resource = handle;
_resource.AddResourceEventListener(this);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
{
terrain0.Dispose();
//terrain2.Dispose();
}
terrain0 = null;
//terrain2 = null;
}
public CollisionSubmeshProvider(ResourceHandle <Resource.HavokCollisionResource> handle, int idx)
{
_resource = handle;
_meshIndex = idx;
}
public NavmeshProvider(ResourceHandle <Resource.NVMNavmeshResource> handle)
{
_resource = handle;
_resource.AddResourceEventListener(this);
}
public CollisionMeshProvider(ResourceHandle <Resource.HavokCollisionResource> res)
{
_resource = res;
//_resource.Acquire();
_resource.AddResourceEventListener(this);
}
public FlverSubmeshProvider(ResourceHandle <Resource.FlverResource> handle, int idx)
{
_resource = handle;
_meshIndex = idx;
}
public FlverMeshProvider(ResourceHandle <Resource.FlverResource> res)
{
_resource = res;
//_resource.Acquire();
_resource.AddResourceEventListener(this);
}
/// <summary>
/// Sets the button's image.
/// </summary>
/// <param name="image">Image bitmap.</param>
/// <param name="center">Determines whether the image should be centered.</param>
public virtual void SetImage(ResourceHandle<Image> imageHandle, bool center = false)
{
if (m_Image == null)
{
m_Image = new ImagePanel(this);
}
m_Image.SetImage(imageHandle);
m_Image.SizeToContents( );
m_Image.SetPosition(Math.Max(Padding.Left, 2), 2);
m_CenterImage = center;
TextPadding = new Padding(m_Image.Right + 2, TextPadding.Top, TextPadding.Right, TextPadding.Bottom);
}
public static void SetResource(Entity entity, ResourceHandle <AudioResource> resource)
{
entity.Set(resource);
}
/// <summary>
/// Draws textured rectangle.
/// </summary>
/// <param name="material">Material to use.</param>
/// <param name="materialHandle">Rectangle bounds.</param>
/// <param name="u1">MaterialHandle coordinate u1.</param>
/// <param name="v1">MaterialHandle coordinate v1.</param>
/// <param name="u2">MaterialHandle coordinate u2.</param>
/// <param name="v2">MaterialHandle coordinate v2.</param>
public virtual void DrawTexturedRect(ResourceHandle <Image> imageHandle, RectangleF rect, float u1 = 0, float v1 = 0, float u2 = 1, float v2 = 1)
{
}
public void TestComplexAuthorization()
{
SetupComplexData();
IAuthorizationProvider provider = Afcas.GetAuthorizationProvider();
Principal PA = ObjectCache.Current.Get <Principal>("PA");
//Principal PB = ObjectCache.Current.Get< Principal >( "PB" );
Principal PC = ObjectCache.Current.Get <Principal>("PC");
Principal PD = ObjectCache.Current.Get <Principal>("PD");
//Principal PE = ObjectCache.Current.Get< Principal >( "PE" );
Principal PF = ObjectCache.Current.Get <Principal>("PF");
//Principal PG = ObjectCache.Current.Get< Principal >( "PG" );
//Principal PH = ObjectCache.Current.Get< Principal >( "PH" );
Principal PI = ObjectCache.Current.Get <Principal>("PI");
Principal PJ = ObjectCache.Current.Get <Principal>("PJ");
Principal PK = ObjectCache.Current.Get <Principal>("PK");
Principal PP = ObjectCache.Current.Get <Principal>("PP");
Principal PQ = ObjectCache.Current.Get <Principal>("PQ");
//Principal PR = ObjectCache.Current.Get< Principal >( "PR" );
//Principal PS = ObjectCache.Current.Get< Principal >( "PS" );
//Principal PT = ObjectCache.Current.Get< Principal >( "PT" );
Operation OA = ObjectCache.Current.Get <Operation>("OA");
Operation OB = ObjectCache.Current.Get <Operation>("OB");
Operation OC = ObjectCache.Current.Get <Operation>("OC");
Operation OD = ObjectCache.Current.Get <Operation>("OD");
Operation OE = ObjectCache.Current.Get <Operation>("OE");
Operation OF = ObjectCache.Current.Get <Operation>("OF");
Operation OG = ObjectCache.Current.Get <Operation>("OG");
Operation OH = ObjectCache.Current.Get <Operation>("OH");
ResourceHandleFactory resFac = Afcas.GetHandleFactory("SampleResource");
ResourceHandle RA = resFac.GenerateResourceHandleByKey("RA");
ResourceHandle RB = resFac.GenerateResourceHandleByKey("RB");
ResourceHandle RC = resFac.GenerateResourceHandleByKey("RC");
//ResourceHandle RD = resFac.GenerateResourceHandleByKey( "RD" );
//ResourceHandle RE = resFac.GenerateResourceHandleByKey( "RE" );
//ResourceHandle RF = resFac.GenerateResourceHandleByKey( "RF" );
//ResourceHandle RG = resFac.GenerateResourceHandleByKey( "RG" );
ResourceHandle RH = resFac.GenerateResourceHandleByKey("RH");
//ResourceHandle RI = resFac.GenerateResourceHandleByKey( "RI" );
//ResourceHandle RJ = resFac.GenerateResourceHandleByKey( "RJ" );
ResourceHandle RK = resFac.GenerateResourceHandleByKey("RK");
ResourceHandle RL = resFac.GenerateResourceHandleByKey("RL");
// explicit auth. list
Assert.That(provider.IsAuthorized(PI.Key, OH.Key, RL));
Assert.That(provider.IsAuthorized(PD.Key, OA.Key, RA));
Assert.That(provider.IsAuthorized(PP.Key, OE.Key, RH));
Assert.That(provider.IsAuthorized(PA.Key, OG.Key, RL));
Assert.That(provider.IsAuthorized(PQ.Key, OB.Key, RL));
Assert.That(provider.IsAuthorized(PF.Key, OC.Key, RB));
//implied ones
Assert.That(provider.IsAuthorized(PI.Key, OA.Key, RA));
Assert.That(provider.IsAuthorized(PI.Key, OE.Key, RC));
Assert.That(provider.IsAuthorized(PI.Key, OF.Key, RK));
Assert.That(provider.IsAuthorized(PK.Key, OF.Key, RA));
Assert.That(provider.IsAuthorized(PK.Key, OE.Key, RC));
Assert.That(provider.IsAuthorized(PK.Key, OF.Key, RK));
Assert.That(provider.IsAuthorized(PK.Key, OH.Key, RL));
Assert.That(provider.IsAuthorized(PJ.Key, OD.Key, RH));
Assert.That(provider.IsAuthorized(PP.Key, OB.Key, RA));
Assert.That(!provider.IsAuthorized(PC.Key, OE.Key, RC));
Assert.That(!provider.IsAuthorized(PP.Key, OB.Key, RL));
}
public override void PrepareVisibleObjects(ICamera cam, int level)
{
//if (level > 0)
//{
// if (terrain1.State == ResourceState.Loaded)
// {
// ActiveTerrain = terrain1;
// }
// else
// {
// terrain1.Touch();
// }
// if (ActiveTerrain != null)
// {
// TerrainMesh tm = ActiveTerrain.Resource;
// tm.PrepareVisibleObjects(cam, level);
// }
//}
//else
{
if (terrain0.State == ResourceState.Loaded)
{
ActiveTerrain = terrain0;
}
else
{
terrain0.Touch();
}
if (ActiveTerrain != null)
{
TerrainMesh tm = ActiveTerrain.Resource;
tm.PrepareVisibleObjects(cam, level);
}
}
}
private static ObjectCache SetupComplexData()
{
DBHelper.ExecuteNonQuery("Test_DeleteAllData");
ObjectCache.PushCurrent(new ObjectCache());
IAuthorizationManager manager = Afcas.GetAuthorizationManager();
Principal PA = Principal.CreatePrincipal("PA", "PA", PrincipalType.Group, "");
Principal PB = Principal.CreatePrincipal("PB", "PB", PrincipalType.Group, "");
Principal PC = Principal.CreatePrincipal("PC", "PC", PrincipalType.Group, "");
Principal PD = Principal.CreatePrincipal("PD", "PD", PrincipalType.Group, "");
Principal PE = Principal.CreatePrincipal("PE", "PE", PrincipalType.User, "");
Principal PF = Principal.CreatePrincipal("PF", "PF", PrincipalType.User, "");
Principal PG = Principal.CreatePrincipal("PG", "PG", PrincipalType.User, "");
Principal PH = Principal.CreatePrincipal("PH", "PH", PrincipalType.Group, "");
Principal PI = Principal.CreatePrincipal("PI", "PI", PrincipalType.Group, "");
Principal PJ = Principal.CreatePrincipal("PJ", "PJ", PrincipalType.User, "");
Principal PK = Principal.CreatePrincipal("PK", "PK", PrincipalType.User, "");
Principal PP = Principal.CreatePrincipal("PP", "PP", PrincipalType.Group, "");
Principal PQ = Principal.CreatePrincipal("PQ", "PQ", PrincipalType.Group, "");
Principal PR = Principal.CreatePrincipal("PR", "PR", PrincipalType.Group, "");
Principal PS = Principal.CreatePrincipal("PS", "PS", PrincipalType.User, "");
Principal PT = Principal.CreatePrincipal("PT", "PT", PrincipalType.User, "");
manager.AddOrUpdate(PA, "");
manager.AddOrUpdate(PB, "");
manager.AddOrUpdate(PC, "");
manager.AddOrUpdate(PD, "");
manager.AddOrUpdate(PE, "");
manager.AddOrUpdate(PF, "");
manager.AddOrUpdate(PG, "");
manager.AddOrUpdate(PH, "");
manager.AddOrUpdate(PI, "");
manager.AddOrUpdate(PJ, "");
manager.AddOrUpdate(PK, "");
manager.AddOrUpdate(PP, "");
manager.AddOrUpdate(PQ, "");
manager.AddOrUpdate(PR, "");
manager.AddOrUpdate(PS, "");
manager.AddOrUpdate(PT, "");
manager.AddGroupMember(PA, PB);
manager.AddGroupMember(PA, PC);
manager.AddGroupMember(PA, PD);
manager.AddGroupMember(PB, PD);
manager.AddGroupMember(PB, PE);
manager.AddGroupMember(PC, PE);
manager.AddGroupMember(PC, PH);
manager.AddGroupMember(PC, PI);
manager.AddGroupMember(PD, PF);
manager.AddGroupMember(PD, PG);
manager.AddGroupMember(PD, PH);
manager.AddGroupMember(PH, PP);
manager.AddGroupMember(PI, PJ);
manager.AddGroupMember(PI, PK);
manager.AddGroupMember(PP, PQ);
manager.AddGroupMember(PP, PR);
manager.AddGroupMember(PQ, PS);
manager.AddGroupMember(PQ, PT);
manager.AddGroupMember(PR, PT);
Operation OA = Operation.CreateOperation("OA", "OA");
Operation OB = Operation.CreateOperation("OB", "OB");
Operation OC = Operation.CreateOperation("OC", "OC");
Operation OD = Operation.CreateOperation("OD", "OD");
Operation OE = Operation.CreateOperation("OE", "OE");
Operation OF = Operation.CreateOperation("OF", "OF");
Operation OG = Operation.CreateOperation("OG", "OG");
Operation OH = Operation.CreateOperation("OH", "OH");
manager.AddSubOperation(OA, OB);
manager.AddSubOperation(OA, OC);
manager.AddSubOperation(OA, OD);
manager.AddSubOperation(OE, OF);
manager.AddSubOperation(OE, OG);
manager.AddSubOperation(OH, OA);
manager.AddSubOperation(OH, OE);
ResourceHandleFactory resFac = Afcas.GetHandleFactory("SampleResource");
ResourceHandle RA = resFac.GenerateResourceHandleByKey("RA");
ResourceHandle RB = resFac.GenerateResourceHandleByKey("RB");
ResourceHandle RC = resFac.GenerateResourceHandleByKey("RC");
ResourceHandle RD = resFac.GenerateResourceHandleByKey("RD");
ResourceHandle RE = resFac.GenerateResourceHandleByKey("RE");
ResourceHandle RF = resFac.GenerateResourceHandleByKey("RF");
ResourceHandle RG = resFac.GenerateResourceHandleByKey("RG");
ResourceHandle RH = resFac.GenerateResourceHandleByKey("RH");
ResourceHandle RI = resFac.GenerateResourceHandleByKey("RI");
ResourceHandle RJ = resFac.GenerateResourceHandleByKey("RJ");
ResourceHandle RK = resFac.GenerateResourceHandleByKey("RK");
ResourceHandle RL = resFac.GenerateResourceHandleByKey("RL");
manager.AddSubResource(RA, RB);
manager.AddSubResource(RA, RC);
manager.AddSubResource(RB, RD);
manager.AddSubResource(RB, RE);
manager.AddSubResource(RC, RE);
manager.AddSubResource(RC, RF);
manager.AddSubResource(RC, RG);
manager.AddSubResource(RH, RI);
manager.AddSubResource(RH, RJ);
manager.AddSubResource(RH, RK);
manager.AddSubResource(RL, RA);
manager.AddSubResource(RL, RH);
manager.AddAccessPredicate(PI.Key, OH.Key, RL, ResourceAccessPredicateType.Grant);
manager.AddAccessPredicate(PD.Key, OA.Key, RA, ResourceAccessPredicateType.Grant);
manager.AddAccessPredicate(PP.Key, OE.Key, RH, ResourceAccessPredicateType.Grant);
manager.AddAccessPredicate(PA.Key, OG.Key, RL, ResourceAccessPredicateType.Grant);
manager.AddAccessPredicate(PQ.Key, OB.Key, RL, ResourceAccessPredicateType.Grant);
manager.AddAccessPredicate(PF.Key, OC.Key, RB, ResourceAccessPredicateType.Grant);
return(ObjectCache.Current);
}
public override void Setup(Material mat, ref RenderOperation op)
{
if (mode == RenderMode.Depth)
{
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
shdVtxShader.SetValue("mvp", ref lightPrjTrans);
}
else if (mode == RenderMode.DeferredNormal)
{
Matrix worldView = op.Transformation * EffectParams.CurrentCamera.ViewMatrix;
Matrix mvp = worldView * EffectParams.CurrentCamera.ProjectionMatrix;
nrmGenVShader.SetValue("mvp", ref mvp);
nrmGenVShader.SetValue("worldView", ref worldView);
if (!stateSetted)
{
ShaderSamplerState state = new ShaderSamplerState();
state.AddressU = TextureAddressMode.Wrap;
state.AddressV = TextureAddressMode.Wrap;
state.AddressW = TextureAddressMode.Wrap;
state.MinFilter = TextureFilter.Linear;
state.MagFilter = TextureFilter.Linear;
state.MipFilter = TextureFilter.Linear;
state.MaxAnisotropy = 8;
state.MipMapLODBias = 0;
nrmGenPShader.SetSamplerState("texDif", ref state);
ResourceHandle <Texture> clrTex = mat.GetTexture(0);
if (clrTex == null)
{
nrmGenPShader.SetTexture("texDif", noTexture);
}
else
{
nrmGenPShader.SetTexture("texDif", clrTex);
}
}
}
else
{
Matrix mvp = op.Transformation * EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix;
vtxShader.SetValue("mvp", ref mvp);
vtxShader.SetValue("world", ref op.Transformation);
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
vtxShader.SetValue("smTrans", lightPrjTrans);
IResourceObject res = op.Sender as IResourceObject;
if (res != null)
{
pixShader.SetValue("amount", new Vector2(res.AmountPer, res.MaxValue));
}
else
{
pixShader.SetValue("amount", new Vector2(123, 456));
}
WorldObject wo = op.Sender as WorldObject;
if (wo != null)
{
pixShader.SetValue("visiblity", wo.Visiblity);
}
else
{
pixShader.SetValue("visiblity", 0.0f);
}
if (!stateSetted)
{
ShaderSamplerState state = new ShaderSamplerState();
state.AddressU = TextureAddressMode.Wrap;
state.AddressV = TextureAddressMode.Wrap;
state.AddressW = TextureAddressMode.Wrap;
state.MinFilter = TextureFilter.Anisotropic;
state.MagFilter = TextureFilter.Anisotropic;
state.MipFilter = TextureFilter.Linear;
state.MaxAnisotropy = 8;
state.MipMapLODBias = 0;
pixShader.SetValue("k_a", mat.Ambient);
pixShader.SetValue("k_d", mat.Diffuse);
pixShader.SetSamplerState("texDif", ref state);
ResourceHandle <Texture> clrTex = mat.GetTexture(0);
if (clrTex == null)
{
pixShader.SetTexture("texDif", noTexture);
}
else
{
pixShader.SetTexture("texDif", clrTex);
}
stateSetted = true;
}
}
}
private static IEnumerable <Element> GetNamespaceAndResourceElements(ElementProviderContext context, string ns)
{
var resources = LocalizationsFacade.GetResourceKeys(ns);
var folders = new List <string>();
var elements = new List <Element>();
foreach (var key in resources)
{
var label = key.Key;
if (label == ns)
{
continue;
}
var labelParts = label.Split('.');
if (!String.IsNullOrEmpty(ns))
{
var nsParts = ns.Split('.');
if (nsParts.Length > labelParts.Length)
{
continue;
}
labelParts = labelParts.Skip(nsParts.Length).ToArray();
label = String.Join(".", labelParts);
}
if (labelParts.Length > 1)
{
var folder = labelParts[0];
if (!folders.Contains(folder))
{
folders.Add(folder);
}
}
else if (labelParts.Length == 1)
{
var token = key.GetDataEntityToken();
var dragAndDropInfo = new ElementDragAndDropInfo(typeof(IResourceKey));
dragAndDropInfo.AddDropType(typeof(NamespaceFolderEntityToken));
dragAndDropInfo.SupportsIndexedPosition = false;
var elementHandle = context.CreateElementHandle(token);
var element = new Element(elementHandle, dragAndDropInfo)
{
VisualData = new ElementVisualizedData
{
Label = label,
ToolTip = label,
HasChildren = false,
Icon = ResourceHandle.BuildIconFromDefaultProvider("localization-element-closed-root"),
OpenedIcon = ResourceHandle.BuildIconFromDefaultProvider("localization-element-opened-root")
}
};
var editActionToken = new WorkflowActionToken(typeof(EditResourceWorkflow), new[] { PermissionType.Edit });
element.AddAction(new ElementAction(new ActionHandle(editActionToken))
{
VisualData = new ActionVisualizedData
{
Label = "Edit",
ToolTip = "Edit",
Icon = new ResourceHandle("Composite.Icons", "generated-type-data-edit"),
ActionLocation = Actions.ActionLocation
}
});
var deleteActionToken = new ConfirmWorkflowActionToken("Are you sure?", typeof(DeleteResourceActionToken));
element.AddAction(new ElementAction(new ActionHandle(deleteActionToken))
{
VisualData = new ActionVisualizedData
{
Label = "Delete",
ToolTip = "Delete",
Icon = new ResourceHandle("Composite.Icons", "generated-type-data-delete"),
ActionLocation = Actions.ActionLocation
}
});
elements.Add(element);
}
}
foreach (var folder in folders.OrderBy(f => f))
{
var handleNamespace = folder;
if (!String.IsNullOrEmpty(ns))
{
handleNamespace = ns + "." + handleNamespace;
}
var folderElement = NamespaceFolderEntityToken.CreateElement(context, folder, handleNamespace);
var deleteActionToken = new ConfirmWorkflowActionToken("Are you sure?", typeof(DeleteNamespaceActionToken));
folderElement.AddAction(new ElementAction(new ActionHandle(deleteActionToken))
{
VisualData = new ActionVisualizedData
{
Label = "Delete",
ToolTip = "Delete",
Icon = new ResourceHandle("Composite.Icons", "generated-type-data-delete"),
ActionLocation = Actions.ActionLocation
}
});
folderElement.AddAction(Actions.GetAddAction());
folderElement.AddAction(Actions.GetExportAction());
yield return(folderElement);
}
foreach (var el in elements)
{
yield return(el);
}
}
ResourceHandle<Material> GetCreateMaterial(ResourceHandle<Image> imageHandle)
{
var id = imageHandle.Id;
if (!materials.ContainsKey(id))
{
var materialHandle = CreateMaterial(imageHandle);
materials.Add(id, materialHandle);
}
return materials[id];
}
public override void DrawTexturedRect(ResourceHandle <Image> imageHandle, RectangleF rect, float u1, float v1, float u2, float v2)
{
rect = Translate(rect);
_guiBuffer.AddRectangle(rect, new Vector2(u1, v1), new Vector2(u2, v1), new Vector2(u2, v2), new Vector2(u1, v2), imageHandle, DrawColor);
}
public IEnumerable <Element> Provide(ElementProviderContext context, EntityToken token)
{
var returnList = new List <Element>();
var dataSourceToken = (DataSourceEntityToken)token;
var type = Type.GetType(dataSourceToken.Type);
if (type != typeof(StringBasedDataSourceAttribute))
{
return(returnList);
}
var form = DynamicFormsFacade.GetFormByName(dataSourceToken.FormName);
if (form == null)
{
return(returnList);
}
var field = form.Model.Fields.Get(dataSourceToken.FieldName);
if (field == null)
{
return(returnList);
}
var dataSource = field.DataSource;
if (dataSource == null)
{
return(returnList);
}
foreach (var entry in dataSource)
{
var fieldsElementHandle = context.CreateElementHandle(new StringBasedDataSourceEntryEntityToken(form.Name, field.Name, entry.Key));
var fieldElement = new Element(fieldsElementHandle)
{
VisualData = new ElementVisualizedData
{
Label = entry.Key,
ToolTip = entry.Key,
HasChildren = false,
Icon = ResourceHandle.BuildIconFromDefaultProvider("localization-element-closed-root"),
OpenedIcon = ResourceHandle.BuildIconFromDefaultProvider("localization-element-opened-root")
}
};
var deleteActionToken = new ConfirmWorkflowActionToken("Delete: " + entry.Key, typeof(DeleteStringBasedDataSourceEntryActionToken));
fieldElement.AddAction(new ElementAction(new ActionHandle(deleteActionToken))
{
VisualData = new ActionVisualizedData
{
Label = "Delete",
ToolTip = "Delete",
Icon = ResourceHandle.BuildIconFromDefaultProvider("generated-type-data-delete"),
ActionLocation = ActionLocation
}
});
returnList.Add(fieldElement);
}
return(returnList);
}
private IEnumerable <Element> GetAvailablePackageGroupFolderChildren(string groupName, SearchToken seachToken)
{
IEnumerable <PackageDescription> packageDescriptions =
(from description in PackageSystemServices.GetFilteredAllAvailablePackages()
where description.GroupName == groupName
orderby description.Name
select description);
foreach (PackageDescription packageDescription in packageDescriptions)
{
ResourceHandle packageIcon = (packageDescription.PriceAmmount > 0 || packageDescription.AvailableInSubscriptions.Any(f => f.Purchasable)
? AvailableCommercialPackageItemIcon : AvailablePackageItemIcon);
Element element = new Element(_context.CreateElementHandle(new PackageElementProviderAvailablePackagesItemEntityToken(
packageDescription.Id.ToString(),
packageDescription.GroupName)));
element.VisualData = new ElementVisualizedData
{
Label = packageDescription.Name,
ToolTip = packageDescription.Name,
HasChildren = false,
Icon = packageIcon,
};
if (!string.IsNullOrEmpty(packageDescription.ConsoleBrowserUrl))
{
element.PropertyBag.Add("BrowserUrl", packageDescription.ConsoleBrowserUrl);
element.PropertyBag.Add("BrowserToolingOn", "false");
}
element.AddAction(new ElementAction(new ActionHandle(new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.Plugins.Elements.ElementProviders.PackageElementProvider.ViewAvailablePackageInfoWorkflowWorkflow"), ActionPermissions)))
{
VisualData = new ActionVisualizedData
{
Label = StringResourceSystemFacade.GetString("Composite.Plugins.PackageElementProvider", "ViewAvailableInformationLabel"),
ToolTip = StringResourceSystemFacade.GetString("Composite.Plugins.PackageElementProvider", "ViewAvailableInformationToolTip"),
Icon = ViewInstalledInformationIcon,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Edit,
IsInFolder = false,
IsInToolbar = true,
ActionGroup = PrimaryActionGroup
}
}
});
element.AddAction(new ElementAction(new ActionHandle(new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.Plugins.Elements.ElementProviders.PackageElementProvider.InstallRemotePackageWorkflow"), ActionPermissions)))
{
VisualData = new ActionVisualizedData
{
Label = StringResourceSystemFacade.GetString("Composite.Plugins.PackageElementProvider", "InstallLabel"),
ToolTip = StringResourceSystemFacade.GetString("Composite.Plugins.PackageElementProvider", "InstallToolTip"),
Icon = InstallIcon,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Add,
IsInFolder = false,
IsInToolbar = true,
ActionGroup = PrimaryActionGroup
}
}
});
yield return(element);
}
}
/// <summary>
/// Draws textured rectangle.
/// </summary>
/// <param name="material">Material to use.</param>
/// <param name="materialHandle">Rectangle bounds.</param>
/// <param name="u1">MaterialHandle coordinate u1.</param>
/// <param name="v1">MaterialHandle coordinate v1.</param>
/// <param name="u2">MaterialHandle coordinate u2.</param>
/// <param name="v2">MaterialHandle coordinate v2.</param>
public virtual void DrawTexturedRect(ResourceHandle<Image> imageHandle, RectangleF rect, float u1=0, float v1=0, float u2=1, float v2=1)
{
}
public static IUiControl Render(
string consoleId,
string elementProviderName,
FlowToken flowToken,
FormFlowUiDefinition formFlowUiCommand,
IFormChannelIdentifier channel,
bool debugMode,
FlowControllerServicesContainer servicesContainer)
{
FlowControllerServicesContainer formServicesContainer = new FlowControllerServicesContainer(servicesContainer);
formServicesContainer.AddService(new FormFlowRenderingService());
formServicesContainer.AddService(new FormFlowWebRenderingService());
IFormMarkupProvider formMarkupProvider = formFlowUiCommand.MarkupProvider;
IFormMarkupProvider customToolbarItemsMarkupProvider = formFlowUiCommand.CustomToolbarItemsMarkupProvider;
Dictionary <string, object> innerFormBindings = formFlowUiCommand.BindingsProvider.GetBindings();
Dictionary <IFormEventIdentifier, FormFlowEventHandler> eventHandlers = formFlowUiCommand.EventHandlers;
Dictionary <string, List <ClientValidationRule> > bindingsValidationRules = formFlowUiCommand.BindingsValidationRules;
FormTreeCompiler formCompiler = new FormTreeCompiler();
IUiContainer renderingContainer = GetRenderingContainer(channel, formFlowUiCommand.UiContainerType);
// Setting state related objects so the delegate below can access them "fresh"
CurrentFormTreeCompiler = formCompiler;
CurrentInnerFormBindings = innerFormBindings;
CurrentControlContainer = (IWebUiContainer)renderingContainer;
Dictionary <string, object> containerEventHandlerStubs = new Dictionary <string, object>();
foreach (IFormEventIdentifier eventIdentifier in eventHandlers.Keys)
{
IFormEventIdentifier localScopeEventIdentifier = eventIdentifier; // See: Local variable usage with anonymous methods within loop control structures
EventHandler handlerStub = delegate(object sender, EventArgs e)
{
try
{
BaseEventHandler(consoleId, elementProviderName, flowToken, formFlowUiCommand, servicesContainer, eventHandlers, localScopeEventIdentifier, formServicesContainer);
}
catch (Exception ex)
{
formServicesContainer.GetService <IManagementConsoleMessageService>().ShowLogEntry(typeof(FormFlowUiDefinitionRenderer), ex);
throw;
}
};
containerEventHandlerStubs.Add(eventIdentifier.BindingName, handlerStub);
if (innerFormBindings.ContainsKey(eventIdentifier.BindingName))
{
innerFormBindings.Remove(eventIdentifier.BindingName);
}
innerFormBindings.Add(eventIdentifier.BindingName, handlerStub);
}
XDocument document;
using (XmlReader formMarkupReader = formMarkupProvider.GetReader())
{
document = XDocument.Load(formMarkupReader);
formMarkupReader.Close();
}
formCompiler.Compile(document, channel, innerFormBindings, debugMode, "", bindingsValidationRules);
IUiControl innerForm = formCompiler.UiControl;
IUiControl customToolbarItems = null;
if (customToolbarItemsMarkupProvider != null)
{
var toolbarCompiler = new FormTreeCompiler();
CurrentCustomToolbarFormTreeCompiler = toolbarCompiler;
using (XmlReader formMarkupReader = customToolbarItemsMarkupProvider.GetReader())
{
toolbarCompiler.Compile(formMarkupReader, channel, innerFormBindings, debugMode, bindingsValidationRules);
}
customToolbarItems = toolbarCompiler.UiControl;
}
CurrentControlTreeRoot = (IWebUiControl)innerForm;
string label = formCompiler.Label;
if (label.IsNullOrEmpty())
{
label = formFlowUiCommand.ContainerLabel ?? "";
}
string labelField = GetFormLabelField(document);
ResourceHandle containerIcon = formCompiler.Icon;
return(renderingContainer.Render(formCompiler.UiControl, customToolbarItems, channel, containerEventHandlerStubs, label, labelField, formCompiler.Tooltip, containerIcon));
}
/// <summary>
/// Gets pixel color of a specified texture. Slow.
/// </summary>
/// <param name="materialHandle"> </param>
/// <param name="x">X.</param>
/// <param name="y">Y.</param>
/// <returns>Pixel color.</returns>
public virtual Color PixelColor(ResourceHandle<Image> imagelHandle, uint x, uint y)
{
return PixelColor(imagelHandle, x, y, Color.White);
}
public async Task ResourceHandle_should_return_the_same_instance()
{
using (var pool = new ResourcePool <IDisposable>(new InstanceHolder().CreateInstance))
using (var handle = new ResourceHandle <IDisposable>(pool))
Assert.That(await handle.ObtainAsync(), Is.SameAs(await handle.ObtainAsync()));
}
public void RemoveSubResource(ResourceHandle resource, ResourceHandle subResource)
{
DBHelper.ExecuteNonQuery("RemoveEdgeWithSpaceSavings", subResource.AfcasKey, resource.AfcasKey, EdgeSource.Resource);
}
public static IEnumerable <Element> GetNamespaceAndFormElements(ElementProviderContext context, string ns)
{
using (var data = new DataConnection())
{
var allModelReferences = data.Get <IModelReference>();
var folders = new List <string>();
var formElements = new List <Element>();
if (String.IsNullOrEmpty(ns))
{
var homepageIds = data.Get <IPageStructure>().Where(s => s.ParentId == Guid.Empty).Select(s => s.Id);
if (homepageIds.Count() > 1)
{
folders.AddRange(homepageIds
.Select(id => PageManager.GetPageById(id))
.Select(page => SanatizeFormName(page.Title)));
}
}
else
{
allModelReferences = allModelReferences.Where(def => def.Name.StartsWith(ns + "."));
}
foreach (var modelReference in allModelReferences)
{
var label = modelReference.Name;
if (!String.IsNullOrEmpty(ns))
{
label = label.Remove(0, ns.Length + 1);
}
var split = label.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
if (split.Length > 1)
{
var folder = split[0];
if (!folders.Contains(folder))
{
folders.Add(folder);
}
}
else if (split.Length == 1)
{
var token = modelReference.GetDataEntityToken();
var elementHandle = context.CreateElementHandle(token);
var formElement = new Element(elementHandle)
{
VisualData = new ElementVisualizedData
{
Label = label,
ToolTip = label,
HasChildren = true,
Icon = ResourceHandle.BuildIconFromDefaultProvider("localization-element-closed-root"),
OpenedIcon = ResourceHandle.BuildIconFromDefaultProvider("localization-element-opened-root")
}
};
formElements.Add(formElement);
}
}
foreach (var folder in folders.OrderBy(f => f))
{
var handleNamespace = folder;
if (!String.IsNullOrEmpty(ns))
{
handleNamespace = ns + "." + handleNamespace;
}
var folderElement = NamespaceFolderEntityToken.CreateElement(context, typeof(FormBuilderElementProvider).Name, folder, handleNamespace);
yield return(folderElement);
}
foreach (var form in formElements)
{
yield return(form);
}
}
}
private Element CreateElement(SimpleVirtualElement simpleElementNode)
{
EntityToken entityToken = new VirtualElementProviderEntityToken(_context.ProviderName, simpleElementNode.Name);
Element element = new Element(_context.CreateElementHandle(entityToken))
{
TagValue = simpleElementNode.Tag,
VisualData = new ElementVisualizedData
{
Label = StringResourceSystemFacade.ParseString(simpleElementNode.Label),
HasChildren = true // fixing refresh problem easy way... was: HasChildren(baseElementNode)
}
};
Action <IEnumerable> collectProviders = null;
// Recursively searching for attached providers
var attachedProviders = new List <AttachProviderVirtualElement>();
collectProviders = currentElements =>
{
attachedProviders.AddRange(currentElements.OfType <AttachProviderVirtualElement>());
currentElements.OfType <SimpleVirtualElement>().ForEach(e => collectProviders(e.Elements));
};
collectProviders(simpleElementNode.Elements);
foreach (var attachedProvider in attachedProviders)
{
if (ElementFacade.ContainsLocalizedData(new ElementProviderHandle(attachedProvider.ProviderName)))
{
element.IsLocaleAware = true;
}
}
if (element.VisualData.HasChildren)
{
ResourceHandle openHandle = IconResourceSystemFacade.GetResourceHandle(simpleElementNode.OpenFolderIconName);
ResourceHandle closeHandle = IconResourceSystemFacade.GetResourceHandle(simpleElementNode.CloseFolderIconName);
closeHandle = closeHandle ?? openHandle;
openHandle = openHandle ?? closeHandle;
if (openHandle == null)
{
openHandle = CommonElementIcons.Folder;
closeHandle = CommonElementIcons.FolderOpen;
}
element.VisualData.Icon = openHandle;
element.VisualData.OpenedIcon = closeHandle;
}
else
{
element.VisualData.Icon = CommonElementIcons.FolderDisabled;
}
return(element);
}
private void AddTeaserInstances(EntityToken entityToken, List <Element> list, PageTeaserPositionFolderEntityToken folderToken)
{
var page = PageManager.GetPageById(new Guid(entityToken.Source));
var instances = TeaserFacade.GetPageTeasers(page, folderToken.Id, false);
foreach (var instance in instances)
{
var attributes = instance.DataSourceId.InterfaceType.GetCustomAttributes(true).ToList();
var icon = new ResourceHandle("Composite.Icons", "dataassociation-rootfolder-closed");
var openedIcon = new ResourceHandle("Composite.Icons", "dataassociation-rootfolder-open");
var iconAttribute = attributes.OfType <IconAttribute>().FirstOrDefault();
if (iconAttribute != null)
{
icon = new ResourceHandle("Composite.Icons", iconAttribute.Name);
if (!String.IsNullOrEmpty(iconAttribute.OpenedName))
{
openedIcon = new ResourceHandle("Composite.Icons", iconAttribute.OpenedName);
}
}
var label = StringResourceSystemFacade.GetString("CompositeC1Contrib.Teasers", "TeaserElementAttachingProvider.NoLabel");
try
{
label = instance.GetLabel();
}
catch (Exception) { }
var elementHandle = _context.CreateElementHandle(new PageTeaserInstanceEntityToken(page, instance));
var teaserElement = new Element(elementHandle)
{
VisualData = new ElementVisualizedData
{
Label = label,
ToolTip = label,
HasChildren = false,
Icon = icon,
OpenedIcon = openedIcon
}
};
var editWorkflowAttribute = attributes.OfType <EditWorkflowAttribute>().FirstOrDefault();
if (editWorkflowAttribute != null)
{
var editActionToken = new WorkflowActionToken(editWorkflowAttribute.EditWorkflowType, new[] { PermissionType.Edit });
teaserElement.AddAction(new ElementAction(new ActionHandle(editActionToken))
{
VisualData = new ActionVisualizedData
{
Label = StringResourceSystemFacade.GetString("CompositeC1Contrib.Teasers", "TeaserElementAttachingProvider.Edit.Label"),
ToolTip = StringResourceSystemFacade.GetString("CompositeC1Contrib.Teasers", "TeaserElementAttachingProvider.Edit.ToolTip"),
Icon = new ResourceHandle("Composite.Icons", "generated-type-data-edit"),
ActionLocation = ActionLocation
}
});
}
var deleteActionToken = new ConfirmWorkflowActionToken(StringResourceSystemFacade.GetString("CompositeC1Contrib.Teasers", "TeaserElementAttachingProvider.DeleteItem") + label, typeof(DeletePageTeaserActionToken));
teaserElement.AddAction(new ElementAction(new ActionHandle(deleteActionToken))
{
VisualData = new ActionVisualizedData
{
Label = StringResourceSystemFacade.GetString("CompositeC1Contrib.Teasers", "TeaserElementAttachingProvider.Delete.Label"),
ToolTip = StringResourceSystemFacade.GetString("CompositeC1Contrib.Teasers", "TeaserElementAttachingProvider.Delete.ToolTip"),
Icon = new ResourceHandle("Composite.Icons", "generated-type-data-delete"),
ActionLocation = ActionLocation
}
});
list.Add(teaserElement);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TexturedSkin"/> class.
/// </summary>
/// <param name="renderer">Renderer to use.</param>
/// <param name="imageHandle">Name of the skin texture map.</param>
/// <param name="defaultFont"> </param>
public TexturedSkin(Renderers.Renderer renderer, ResourceHandle<Image> imageHandle, Font defaultFont)
: base(renderer, defaultFont)
{
this.imageHandle = imageHandle;
InitializeColors();
InitializeTextures();
}
public void DrawTexturedRect(ResourceHandle<Image> imageHandle, RectangleF rect, Vector2 topLeftUV, Vector2 topRightUV, Vector2 bottomRightUV, Vector2 bottomLeftUV)
{
rect = Translate(rect);
_guiBuffer.AddRectangle(rect,topLeftUV,topRightUV,bottomRightUV,bottomLeftUV, imageHandle, DrawColor);
}
protected void AddQuad(IntPtr v1, IntPtr v2, IntPtr v3, IntPtr v4, uint structSize, ResourceHandle <Material> materialHandle)
{
var batchInfo = GetCreateBatchInfo(materialHandle);
batchInfo.Ranges.Add((int)gb.NumVertices);
gb.Add(v1, structSize);
gb.Add(v2, structSize);
gb.Add(v3, structSize);
gb.Add(v4, structSize);
}
public void AddRectangle(RectangleF rect,
Vector2 topLeftUV, Vector2 topRightUV, Vector2 bottomRightUV, Vector2 bottomLeftUV,
ResourceHandle<Material> materialHandle, Color color)
{
Vertex v1, v2, v3, v4;
InitVetexes(out v1, out v2, out v3, out v4,
rect, color,
topLeftUV, topRightUV, bottomRightUV, bottomLeftUV);
unsafe
{
AddQuad(new IntPtr(&v1),new IntPtr(&v2),new IntPtr(&v3),new IntPtr(&v4), (uint)sizeof(Vertex), materialHandle);
}
}
/// <summary>
/// Initializes the <see cref="ErrorWarnInfoProvider"/> class.
/// </summary>
static ErrorWarnInfoProvider()
{
DefaultIconInformation = new AssemblyResourceHandle(typeof(ErrorWarnInfoProvider), "CslaContrib.WebGUI.Resources.InformationIcon.png");
DefaultIconWarning = new AssemblyResourceHandle(typeof(ErrorWarnInfoProvider), "CslaContrib.WebGUI.Resources.WarningIcon.png");
DefaultIconError = new AssemblyResourceHandle(typeof(ErrorWarnInfoProvider), "CslaContrib.WebGUI.Resources.ErrorIcon.png");
}
protected void AddQuad(IntPtr v1, IntPtr v2, IntPtr v3, IntPtr v4, uint structSize, ResourceHandle<Image> imageHandle)
{
var materialHandle = GetCreateMaterial(imageHandle);
AddQuad(v1, v2, v3, v4, structSize, materialHandle);
}
public override void DrawTexturedRect(ResourceHandle<Image> imageHandle, RectangleF rect, float u1, float v1, float u2, float v2)
{
rect = Translate(rect);
_guiBuffer.AddRectangle(rect, new Vector2(u1,v1), new Vector2(u2,v1), new Vector2(u2,v2), new Vector2(u1,v2), imageHandle, DrawColor);
}
public void DrawTexturedRect(ResourceHandle <Image> imageHandle, RectangleF rect, Vector2 topLeftUV, Vector2 topRightUV, Vector2 bottomRightUV, Vector2 bottomLeftUV)
{
rect = Translate(rect);
_guiBuffer.AddRectangle(rect, topLeftUV, topRightUV, bottomRightUV, bottomLeftUV, imageHandle, DrawColor);
}
public override Color PixelColor(ResourceHandle<Image> imageHandle, uint x, uint y, Color defaultColor)
{
var image = imageHandle.Resolve();
if(image == null || image.Width == 0)
return defaultColor;
var offset = (int)(4 * (x + y * image.Width));
var data = image.Buffer;
var pixel = new Color(data[offset + 0],
data[offset + 1], data[offset + 2], data[offset + 3]);
return pixel;
}
public override void SetContainerIcon(ResourceHandle icon)
{
this.ContainerIcon = icon;
}
protected override ResourceHandle<Material> CreateMaterial(ResourceHandle<Image> imageHandle)
{
var materialHandle = Material.Create(Allocator.GetHeap(), "GwenGui");
var mat = materialHandle.Resolve();
mat.BackfaceCulling = false;
mat.SetBlending(BlendSource.SourceAlpha, BlendDestination.InverseSourceAlpha);
if (imageHandle.Id == ResourceHandle<Image>.Invalid)
{
mat.SetShader("VertexColor");
}
else
{
mat.SetShader("TexColor");
mat.SetTexture(0, imageHandle);
mat.GetTextureUnit(0).WrapMode = TextureWrapMode.Clamp;
}
return materialHandle;
}
private static TreeNode BuildDataElementsTreeNode(XElement element, Tree tree)
{
XAttribute typeAttribute = element.Attribute("Type");
XAttribute labelAttribute = element.Attribute("Label");
XAttribute toolTipAttribute = element.Attribute("ToolTip");
XAttribute iconAttribute = element.Attribute("Icon");
XAttribute openedIconAttribute = element.Attribute("OpenedIcon");
XAttribute showForeignItemsAttribute = element.Attribute("ShowForeignItems");
XAttribute leafDisplayAttribute = element.Attribute("Display");
XAttribute browserUrlAttribute = element.Attribute("BrowserUrl");
XAttribute browserImagelAttribute = element.Attribute("BrowserImage");
if (typeAttribute == null)
{
tree.AddValidationError(element, "TreeValidationError.Common.MissingAttribute", "Type");
return(null);
}
Type interfaceType = TypeManager.TryGetType(typeAttribute.Value);
if (interfaceType == null)
{
tree.AddValidationError(element, "TreeValidationError.Common.UnknownInterfaceType",
typeAttribute.Value);
return(null);
}
LeafDisplayMode leafDisplay = LeafDisplayModeHelper.ParseDisplayMode(leafDisplayAttribute, tree);
ResourceHandle icon = null;
if (iconAttribute != null)
{
icon = FactoryHelper.GetIcon(iconAttribute.Value);
}
ResourceHandle openedIcon = null;
if (icon != null && openedIconAttribute == null)
{
openedIcon = icon;
}
else if (openedIconAttribute != null)
{
openedIcon = FactoryHelper.GetIcon(openedIconAttribute.Value);
}
var dataElementsTreeNode = new DataElementsTreeNode
{
Tree = tree,
Id = tree.BuildProcessContext.CreateNewNodeId(),
InterfaceType = interfaceType,
Label = labelAttribute.GetValueOrDefault(null),
ToolTip = toolTipAttribute.GetValueOrDefault(null),
Icon = icon,
OpenedIcon = openedIcon,
ShowForeignItems = showForeignItemsAttribute.GetValueOrDefault("true").ToLowerInvariant() == "true",
Display = leafDisplay,
BrowserUrl = browserUrlAttribute.GetValueOrDefault(null),
BrowserImage = browserImagelAttribute.GetValueOrDefault(null),
};
List <TreeNode> treeNodes;
if (tree.BuildProcessContext.DataInteraceToTreeNodes.TryGetValue(interfaceType, out treeNodes) == false)
{
treeNodes = new List <TreeNode>();
tree.BuildProcessContext.DataInteraceToTreeNodes.Add(interfaceType, treeNodes);
}
treeNodes.Add(dataElementsTreeNode);
return(dataElementsTreeNode);
}
protected unsafe void AddQuad(IntPtr v1, IntPtr v2, IntPtr v3, IntPtr v4, uint structSize, ResourceHandle<Material> materialHandle)
{
var batchInfo = GetCreateBatchInfo(materialHandle);
batchInfo.Ranges.Add((int) gb.NumVertices);
gb.Add((byte*)v1.ToPointer(), structSize);
gb.Add((byte*)v2.ToPointer(), structSize);
gb.Add((byte*)v3.ToPointer(), structSize);
gb.Add((byte*)v4.ToPointer(), structSize);
}
public override void Setup(Material mat, ref RenderOperation op)
{
if (mode == RenderMode.Depth)
{
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
shdVtxShader.SetValue("mvp", ref lightPrjTrans);
}
else if (mode == RenderMode.DeferredNormal)
{
Matrix worldView = op.Transformation * EffectParams.CurrentCamera.ViewMatrix;
Matrix mvp = worldView * EffectParams.CurrentCamera.ProjectionMatrix;
nrmGenVShader.SetValue("mvp", ref mvp);
nrmGenVShader.SetValue("worldView", ref worldView);
if (!stateSetted)
{
ShaderSamplerState state = new ShaderSamplerState();
state.AddressU = TextureAddressMode.Wrap;
state.AddressV = TextureAddressMode.Wrap;
state.AddressW = TextureAddressMode.Wrap;
state.MinFilter = TextureFilter.Linear;
state.MagFilter = TextureFilter.Linear;
state.MipFilter = TextureFilter.Linear;
state.MaxAnisotropy = 8;
state.MipMapLODBias = 0;
nrmGenPShader.SetSamplerState("texDif", ref state);
ResourceHandle <Texture> clrTex = mat.GetTexture(0);
if (clrTex != null)
{
nrmGenPShader.SetTexture("texDif", clrTex);
}
}
}
else
{
Matrix mvp = op.Transformation * EffectParams.CurrentCamera.ViewMatrix * EffectParams.CurrentCamera.ProjectionMatrix;
vtxShader.SetValue("mvp", ref mvp);
vtxShader.SetValue("world", ref op.Transformation);
Matrix lightPrjTrans;
Matrix.Multiply(ref op.Transformation, ref EffectParams.DepthViewProj, out lightPrjTrans);
vtxShader.SetValue("smTrans", lightPrjTrans);
City sender = op.Sender as City;
pixShader.SetValue("k_a", mat.Ambient);
if (sender != null && sender.IsCaptured)
{
Color4F color = new Color4F(sender.Owner.SideColor);
pixShader.SetValue("k_d", color);
}
else
{
pixShader.SetValue("k_d", mat.Diffuse);
}
if (!stateSetted)
{
ShaderSamplerState state = new ShaderSamplerState();
state.AddressU = TextureAddressMode.Wrap;
state.AddressV = TextureAddressMode.Wrap;
state.AddressW = TextureAddressMode.Wrap;
state.MinFilter = TextureFilter.Anisotropic;
state.MagFilter = TextureFilter.Anisotropic;
state.MipFilter = TextureFilter.Linear;
state.MaxAnisotropy = 8;
state.MipMapLODBias = 0;
pixShader.SetSamplerState("texDif", ref state);
ResourceHandle <Texture> clrTex = mat.GetTexture(0);
if (clrTex != null)
{
pixShader.SetTexture("texDif", clrTex);
}
stateSetted = true;
}
}
}
BatchInfo GetCreateBatchInfo(ResourceHandle<Material> materialHandle)
{
if (!batches.ContainsKey(materialHandle.Id))
{
var batch = new RenderBatch
{
GeometryBuffer = gb,
RenderLayer = RenderLayer.Overlays,
PrimitiveType = PrimitiveType.Quads,
Material = materialHandle
};
var batchInfo = new BatchInfo {Batch = batch, Ranges = new List<int>()};
batches[materialHandle.Id] = batchInfo;
}
return batches[materialHandle.Id];
}
public byte[] SaveShellHandle(ResourceHandle handle)
{
return(((ShellFileHandle)handle).SaveIdList());
}
public IEnumerable <ElementAction> Provide(EntityToken entityToken)
{
var token = (FormFieldEntityToken)entityToken;
var defintion = DynamicFormsFacade.GetFormByName(token.FormName);
if (defintion == null)
{
yield break;
}
var field = defintion.Model.Fields.Get(token.FieldName);
if (field == null)
{
yield break;
}
var editActionToken = new WorkflowActionToken(typeof(EditFormFieldWorkflow));
yield return(new ElementAction(new ActionHandle(editActionToken))
{
TagValue = "edit",
VisualData = new ActionVisualizedData
{
Label = "Edit",
ToolTip = "Edit",
Icon = ResourceHandle.BuildIconFromDefaultProvider("generated-type-data-edit"),
ActionLocation = ActionLocation
}
});
var deleteActionToken = new ConfirmWorkflowActionToken("Delete: " + field.Name, typeof(DeleteFormFieldActionToken));
yield return(new ElementAction(new ActionHandle(deleteActionToken))
{
VisualData = new ActionVisualizedData
{
Label = "Delete",
ToolTip = "Delete",
Icon = ResourceHandle.BuildIconFromDefaultProvider("generated-type-data-delete"),
ActionLocation = ActionLocation
}
});
if (!field.Attributes.OfType <DataSourceAttribute>().Any())
{
var addDataSourceActionToken = new WorkflowActionToken(typeof(AddDataSourceWorkflow));
yield return(new ElementAction(new ActionHandle(addDataSourceActionToken))
{
VisualData = new ActionVisualizedData
{
Label = "Add datasource",
ToolTip = "Add datasource",
Icon = ResourceHandle.BuildIconFromDefaultProvider("generated-type-data-edit"),
ActionLocation = ActionLocation
}
});
}
}
protected abstract ResourceHandle <Material> CreateMaterial(ResourceHandle <Image> imageHandle);
