public override void Draw(Microsoft.Xna.Framework.Graphics.Texture2D ImageToProcess, RenderHelper rHelper, Microsoft.Xna.Framework.GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
{
if (firstTime)
{
oldViewProjection = world.CameraManager.ActiveCamera.ViewProjection;
firstTime = false;
}
effect.Parameters["attenuation"].SetValue(Attenuation);
effect.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
effect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(world.CameraManager.ActiveCamera.ViewProjection));
effect.Parameters["oldViewProjection"].SetValue(oldViewProjection);
effect.Parameters["numSamples"].SetValue(NumSamples);
effect.Parameters["depth"].SetValue(rHelper[PrincipalConstants.DephRT]);
effect.Parameters["extra"].SetValue(rHelper[PrincipalConstants.extra1RT]);
effect.Parameters["cena"].SetValue(ImageToProcess);
oldViewProjection = world.CameraManager.ActiveCamera.ViewProjection;
if (useFloatBuffer)
rHelper.RenderFullScreenQuadVertexPixel(effect, SamplerState.PointClamp);
else
rHelper.RenderFullScreenQuadVertexPixel(effect, GraphicInfo.SamplerState);
}
protected override void Draw(GameTime gameTime, RenderHelper render)
{
base.Draw(gameTime, render);
render.RenderTextComplete("PloobsEngine on Windows Phone7", new Vector2(20, 10), Color.Red, Matrix.Identity);
if(result != null)
render.RenderTextComplete(result, new Vector2(20, 30), Color.Red, Matrix.Identity);
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
if (changeColors)
{
rHelper.PushRenderTarget(target);
toon.Parameters["ColorMap"].SetValue(ImageToProcess);
toon.Parameters["useLight"].SetValue(useLight);
toon.Parameters["TexColor"].SetValue(rHelper[PrincipalConstants.colorRT]);
toon.Parameters["CelMap"].SetValue(cell);
toon.Parameters["LightMap"].SetValue(rHelper[PrincipalConstants.lightRt]);
toon.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
if (useFloatingBuffer)
rHelper.RenderFullScreenQuadVertexPixel(toon, SamplerState.PointClamp);
else
rHelper.RenderFullScreenQuadVertexPixel(toon, GraphicInfo.SamplerState);
ImageToProcess = rHelper.PopRenderTargetAsSingleRenderTarget2D();
}
line.Parameters["Thickness"].SetValue(1.0f);
line.Parameters["Threshold"].SetValue(0.2f);
if (useFloatingBuffer)
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, line, GraphicInfo.FullScreenRectangle, SamplerState.PointClamp);
else
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, line, GraphicInfo.FullScreenRectangle, GraphicInfo.SamplerState);
}
protected override void Draw(GameTime gt, IObject obj, RenderHelper render, ICamera cam, IList<ILight> lights)
{
Vector3 dir = cam.Target - cam.Position;
dir.Normalize();
_shader.Parameters["forward"].SetValue(dir);
_shader.Parameters["camUp"].SetValue(cam.Up);
_shader.Parameters["scaleX"].SetValue(scale.X);
_shader.Parameters["scaleY"].SetValue(scale.Y);
_shader.Parameters["xWorld"].SetValue(obj.PhysicObject.WorldMatrix);
_shader.Parameters["xView"].SetValue(cam.View);
_shader.Parameters["xProjection"].SetValue(cam.Projection);
//_shader.Parameters["xBillboardTexture"].SetValue(obj.Modelo.getTexture(TextureType.DIFFUSE,0,0));
render.Textures[0] = obj.Modelo.getTexture(TextureType.DIFFUSE, 0, 0);
_shader.Parameters["atenuation"].SetValue(atenuation);
render.PushRasterizerState(RasterizerState.CullNone);
BatchInformation batchInfo = obj.Modelo.GetBatchInformation(0)[0];
{
_shader.Parameters["alphaTest"].SetValue(alphaTestLimit);
render.RenderBatch(batchInfo, _shader);
}
render.PopRasterizerState();
}
public override void Draw(Microsoft.Xna.Framework.Graphics.Texture2D ImageToProcess, RenderHelper rHelper, Microsoft.Xna.Framework.GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
{
//mix with last frame downsampled
if (tex != null)
{
rHelper.PushRenderTarget(rtend);
rHelper.RenderTextureComplete(tex, Color.FromNonPremultiplied(255, 255, 255, 255), GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.LinearClamp);
rHelper.RenderTextureComplete(ImageToProcess, Color.FromNonPremultiplied(255, 255, 255, Amount), GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.LinearClamp, BlendState.AlphaBlend);
end = rHelper.PopRenderTargetAsSingleRenderTarget2D();
}
//DownSample
rHelper.PushRenderTarget(rt);
rHelper.Clear(Color.Black);
if (end == null)
{
rHelper.RenderTextureComplete(ImageToProcess, Color.White, rt.Bounds, Matrix.Identity, ImageToProcess.Bounds, true, SpriteSortMode.Deferred, SamplerState.AnisotropicClamp);
}
else
{
rHelper.RenderTextureComplete(end, Color.White, rt.Bounds, Matrix.Identity, ImageToProcess.Bounds, true, SpriteSortMode.Deferred, SamplerState.AnisotropicClamp);
}
tex = rHelper.PopRenderTargetAsSingleRenderTarget2D();
if(end!=null)
rHelper.RenderTextureComplete(end, Color.White, GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.LinearClamp);
else
rHelper.RenderTextureComplete(ImageToProcess, Color.White, GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.LinearClamp);
}
public void ClearGBuffer(RenderHelper render)
{
render.PushDepthStencilState(DepthStencilState.None);
clearBufferEffect.Parameters["BackColor"].SetValue(backGroundColor.ToVector3());
render.RenderFullScreenQuadVertexPixel(clearBufferEffect);
render.PopDepthStencilState();
}
public void PreDrawScene(GameTime gameTime, IWorld world, RenderHelper render, GraphicInfo ginfo,List<IObject> objs)
{
foreach (IObject item in objs)
{
item.Material.PreDrawnPhase(gameTime,world, item,world.CameraManager.ActiveCamera, world.Lights, render);
}
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
if(useFloatingBuffer)
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, effect, GraphicInfo.FullScreenRectangle, SamplerState.PointClamp);
else
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, effect, GraphicInfo.FullScreenRectangle, GraphicInfo.SamplerState);
}
protected override void Draw(GameTime gameTime, RenderHelper render)
{
render.RenderTextureComplete(texture, Color.White, GraphicInfo.FullScreenRectangle, Matrix.Identity);
render.RenderTextComplete("Demo 17-22:Texture Generates On the fly ", new Vector2(10, 15), Color.White, Matrix.Identity);
render.RenderTextComplete("Random Texture generated Procedurally on CPU", new Vector2(10, 35), Color.White, Matrix.Identity);
render.RenderTextComplete("Hit Space to change the texture", new Vector2(10, 55), Color.White, Matrix.Identity);
}
/// <summary>
/// This is called when the screen should draw itself.
/// </summary>
/// <param name="gameTime"></param>
/// <param name="render"></param>
protected override void Draw(GameTime gameTime, RenderHelper render)
{
base.Draw(gameTime, render);
///Draw some text on the screen
render.RenderTextComplete("Demo: Basic Screen Forward", new Vector2(GraphicInfo.Viewport.Width - 315, 15), Color.White, Matrix.Identity);
}
/// <summary>
/// This is called when the screen should draw itself.
/// </summary>
/// <param name="gameTime"></param>
/// <param name="render"></param>
protected override void Draw(GameTime gameTime, RenderHelper render)
{
base.Draw(gameTime, render);
///Draw some text on the screen
render.RenderTextComplete("Demo: Basic Screen Forward (Move the camera using WASD and Mouse)", new Vector2(10, 15), Color.Red, Matrix.Identity);
}
public override void Draw(Texture2D ImageToProcess,RenderHelper rHelper, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
rHelper.PushRenderTarget(renderTarget1);
Saturate.Parameters["current"].SetValue(ImageToProcess);
Saturate.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
if(useFloatingBuffer)
rHelper.RenderFullScreenQuadVertexPixel(Saturate,SamplerState.PointClamp);
else
rHelper.RenderFullScreenQuadVertexPixel(Saturate, SamplerState.LinearClamp);
Texture2D t = rHelper.PopRenderTargetAsSingleRenderTarget2D();
rHelper.PushRenderTarget(renderTarget0);
gaussian.Draw(t, rHelper, gt, GraphicInfo, world,useFloatingBuffer);
Texture2D x = rHelper.PopRenderTargetAsSingleRenderTarget2D();
rHelper.Clear(Color.Black);
Combine.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
Combine.Parameters["base"].SetValue(ImageToProcess);
Combine.Parameters["last"].SetValue(x);
if (useFloatingBuffer)
rHelper.RenderFullScreenQuadVertexPixel(Combine , SamplerState.PointClamp);
else
rHelper.RenderFullScreenQuadVertexPixel(Combine, GraphicInfo.SamplerState);
}
/// <summary>
/// Function to initialise the particle system. Has to be called before the first call to RenderFrame.
/// </summary>
/// <param name="settings">Particle system settings</param>
/// <param name="context">Particle system context</param>
public void Init(Context context, RenderHelper renderHelper)
{
Particles = new List<Particle>();
Context = context;
RenderHelper = renderHelper;
Initialise();
}
void rt_RenderBackGround(GraphicInfo ginfo,RenderHelper render)
{
Rectangle source = new Rectangle(0, 0, ginfo.Viewport.Width, ginfo.Viewport.Height);
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Deferred, SamplerState.LinearWrap, BlendState.Opaque, RasterizerState.CullNone,DepthStencilState.Default);
render.RenderTexture(tile, Vector2.Zero, source, Color.White, 0, Vector2.Zero, 1.0f, SpriteEffects.None, 1.0f);
render.RenderEnd();
}
/// <summary>
/// DownSample a Color Texture (using hardware Linear filtering, cant be used on Single/float Textures)
/// </summary>
/// <param name="render">The render.</param>
/// <param name="Texture2D">The texture2 D.</param>
/// <param name="SamplerState">State of the sampler.</param>
/// <returns></returns>
public Texture2D DownColorTexture(RenderHelper render, Texture2D Texture2D, SamplerState SamplerState)
{
render.PushRenderTarget(RenderTarget2D);
render.RenderTextureComplete(Texture2D, Color.White,
Rectangle, Matrix.Identity, Texture2D.Bounds,
true, SpriteSortMode.Deferred, SamplerState);
return render.PopRenderTargetAsSingleRenderTarget2D();
}
public void ClearGBuffer(RenderHelper render)
{
render.ValidateSamplerStates();
render.PushDepthStencilState(DepthStencilState.None);
render.RenderFullScreenQuadVertexPixel(clearBufferEffect);
render.PopDepthStencilState();
render.ValidateSamplerStates();
}
protected override void Draw(GameTime gameTime, RenderHelper render)
{
///must be called before
base.Draw(gameTime, render);
///Draw some text to the screen
render.RenderTextComplete("Most Basic Physx Setup", new Vector2(20, 15), Color.White, Matrix.Identity);
render.RenderTextComplete("In all physx Demos you can throw balls using left mouse buttom", new Vector2(20, 35), Color.White, Matrix.Identity);
}
protected override void Draw(GameTime gameTime, RenderHelper render)
{
base.Draw(gameTime, render);
render.RenderTextComplete("PloobsEngine Gestures with Windows Phone7", new Vector2(20, 10), Color.Red, Matrix.Identity);
render.RenderTextComplete("DoubleTap Count " + doubleTapCount, new Vector2(20, 30), Color.Red, Matrix.Identity);
if(doubleTapDisabled)
render.RenderTextComplete("DoubleTap Disabled" , new Vector2(20, 50), Color.Red, Matrix.Identity);
}
public override void Draw(Microsoft.Xna.Framework.Graphics.Texture2D ImageToProcess, RenderHelper rHelper, Microsoft.Xna.Framework.GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
{
if (useFloatBuffer)
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, effect, GraphicInfo.FullScreenRectangle, SamplerState.PointClamp);
else
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, effect, GraphicInfo.FullScreenRectangle, GraphicInfo.SamplerState);
}
public override void Draw(Microsoft.Xna.Framework.Graphics.Texture2D ImageToProcess, RenderHelper rHelper, Microsoft.Xna.Framework.GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
{
//effect.Parameters["timervalue"].SetValue(m_Timer);
if (useFloatBuffer)
rHelper.RenderFullScreenQuadVertexPixel(effect,SamplerState.PointClamp);
else
rHelper.RenderFullScreenQuadVertexPixel(effect,SamplerState.LinearClamp);
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
hsv.Parameters["cena"].SetValue(ImageToProcess);
hsv.Parameters["toMultiply"].SetValue(toMultiply);
hsv.Parameters["toAdd"].SetValue(toAdd);
if (useFloatingBuffer)
rHelper.RenderFullScreenQuadVertexPixel(hsv, SamplerState.PointClamp);
else
rHelper.RenderFullScreenQuadVertexPixel(hsv, GraphicInfo.SamplerState);
}
public void PreDrawScene(GameTime gameTime, IWorld world, RenderHelper render, GraphicInfo ginfo, List<IObject> objectsToPreDraw)
{
render.ValidateSamplerStates();
foreach (IObject item in objectsToPreDraw)
{
if(item.Material.IsVisible)
item.Material.PreDrawnPhase(gameTime,world, item,world.CameraManager.ActiveCamera, world.Lights, render);
}
render.ValidateSamplerStates();
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
//Draw a quad using the "effect", passing the CurrentImage as a Parameter
effect.Parameters["saturation"].SetValue(saturation);
if (useFloatingBuffer)
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, effect, GraphicInfo.FullScreenRectangle, SamplerState.PointClamp);
else
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, effect, GraphicInfo.FullScreenRectangle, GraphicInfo.SamplerState);
}
public override void Draw(Microsoft.Xna.Framework.Graphics.Texture2D ImageToProcess, RenderHelper rHelper, Microsoft.Xna.Framework.GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
{
effect.Parameters["extrart"].SetValue(rHelper[PrincipalConstants.extra1RT]);
effect.Parameters["backtex"].SetValue(BackGroundTexture);
if (useFloatBuffer)
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, effect, GraphicInfo.FullScreenRectangle, SamplerState.PointClamp);
else
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, effect, GraphicInfo.FullScreenRectangle, GraphicInfo.SamplerState);
}
protected override void Draw(GameTime gameTime, RenderHelper render)
{
if (drawBackground)
{
int w = render.GetViewPort().Width;
int h = render.GetViewPort().Height;
render.RenderTextureComplete(backT, Color.White, new Rectangle(0, 0, w, h), Matrix.Identity);
}
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
effect.Parameters["EXTRA"].SetValue(rHelper[PrincipalConstants.extra1RT]);
effect.Parameters["color"].SetValue(ImageToProcess);
effect.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
if (useFloatingBuffer)
rHelper.RenderFullScreenQuadVertexPixel(effect, SamplerState.PointClamp);
else
rHelper.RenderFullScreenQuadVertexPixel(effect, GraphicInfo.SamplerState);
}
/// <summary>
/// This is called when the screen should draw itself.
/// </summary>
/// <param name="gameTime"></param>
/// <param name="render"></param>
protected override void Draw(GameTime gameTime, RenderHelper render)
{
base.Draw(gameTime, render);
Texture2D logo = GraphicFactory.GetTexture2D("Textures\\engine_logo");
int wd = 64;
int hg = 48;
render.RenderTextureComplete(logo, new Rectangle(this.GraphicInfo.BackBufferWidth - wd, this.GraphicInfo.BackBufferHeight - hg, wd, hg));
render.RenderTextComplete("Basic Screen Forward", new Vector2(GraphicInfo.Viewport.Width - 315, 15), Color.White, Matrix.Identity);
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
//if (Keyboard.GetState().IsKeyDown(Keys.Space))
//{
// rHelper.RenderTextureComplete(ImageToProcess);
// return;
//}
rHelper.PushRenderTarget(rt0);
rHelper.Clear(Color.Transparent);
if (mLAntiAliasingEdgeDetectionMode == MLAntiAliasingEdgeDetectionMode.Color)
effect.CurrentTechnique = effect.Techniques["ColorEdgeDetection"];
else
{
effect.CurrentTechnique = effect.Techniques["DepthEdgeDetection"];
effect.Parameters["depthTex"].SetValue(rHelper[PrincipalConstants.DephRT]);
}
effect.Parameters["PIXEL_SIZE"].SetValue(GraphicInfo.HalfPixel * 2);
effect.Parameters["colorTex"].SetValue(rHelper[PrincipalConstants.CombinedImage]);
effect.Parameters["threshold"].SetValue(0.0008f);
rHelper.RenderFullScreenQuadVertexPixel(effect);
Texture edges = rHelper.PopRenderTargetAsSingleRenderTarget2D();
rHelper.PushRenderTarget(rt1);
rHelper.Clear(Color.Transparent);
effect.CurrentTechnique = effect.Techniques["BlendWeightCalculation"];
effect.Parameters["areaTex"].SetValue(tex);
effect.Parameters["edgesTex"].SetValue(edges);
effect.Parameters["MAX_SEARCH_STEPS"].SetValue(16);
effect.Parameters["MAX_DISTANCE"].SetValue(65);
rHelper.RenderFullScreenQuadVertexPixel(effect);
Texture2D tt = rHelper.PopRenderTargetAsSingleRenderTarget2D();
rHelper.Clear(Color.Transparent);
pass.Parameters["cena"].SetValue(ImageToProcess);
//if (Keyboard.GetState().IsKeyDown(Keys.RightAlt))
//{
// rHelper.RenderTextureComplete(tt);
// return;
//}
//else
//{
//pass.Parameters["cena"].SetValue(ImageToProcess);
rHelper.RenderFullScreenQuadVertexPixel(pass);
//}
effect.CurrentTechnique = effect.Techniques["NeighborhoodBlending"];
effect.Parameters["colorTex"].SetValue(ImageToProcess);
effect.Parameters["blendTex"].SetValue(tt);
rHelper.RenderFullScreenQuadVertexPixel(effect);
}
public override void Draw(Microsoft.Xna.Framework.Graphics.Texture2D ImageToProcess, RenderHelper rHelper, Microsoft.Xna.Framework.GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
{
m_Timer += (float)gt.ElapsedGameTime.Milliseconds / 500;
effect.Parameters["vecTime"].SetValue(m_Timer);
effect.Parameters["vecSkill1"].SetValue(vecSkill1);
if (useFloatBuffer)
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, effect, GraphicInfo.FullScreenRectangle, SamplerState.PointClamp);
else
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, effect, GraphicInfo.FullScreenRectangle, GraphicInfo.SamplerState);
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
m_Timer += (float)gt.ElapsedGameTime.Milliseconds / 500;
noise.Parameters["fTimer"].SetValue(m_Timer);
noise.Parameters["iSeed"].SetValue(1337);
noise.Parameters["fNoiseAmount"].SetValue(0.01f);
if (useFloatingBuffer)
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, noise, GraphicInfo.FullScreenRectangle, SamplerState.PointClamp);
else
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, noise, GraphicInfo.FullScreenRectangle, GraphicInfo.SamplerState);
}
void snapTimer_Tick(object sender, EventArgs e)
{
snapTimer.Stop();
this.XamlDocument.PreviewImage = RenderHelper.HwndToBitmap(ContentArea.Handle);
}
public Task <string> RenderAsync(RenderContext context, ComponentSetting settings)
{
if (settings == null || string.IsNullOrWhiteSpace(settings.NameOrId))
{
return(null);
}
var sitedb = context.WebSite.SiteDb();
var formid = Data.IDGenerator.GetOrGenerate(settings.NameOrId, ConstObjectType.Form);
var form = sitedb.Forms.Get(formid);
if (form == null)
{
return(null);
}
var formsetting = sitedb.FormSetting.GetByFormId(form.Id);
string body = form.Body;
if (body.IndexOf("<form", StringComparison.OrdinalIgnoreCase) == -1)
{
body = "<form>" + body + "</form>";
}
if (formsetting == null || formsetting.Enable == false || string.IsNullOrWhiteSpace(formsetting.FormSubmitter))
{
return(Task.FromResult(body));
}
var computeHash = Lib.Security.Hash.ComputeHashGuid(body);
if (computeHash != this.FormHash)
{
this.FormHash = computeHash;
// reset form...
var el = GetFormElement(body);
this.FormAttributes = new Dictionary <string, string>();
foreach (var item in el.attributes)
{
this.FormAttributes.Add(item.name, item.value);
}
this.bodyRenderTask = RenderEvaluator.Evaluate(el.InnerHtml, new EvaluatorOption());
}
string submiturl = Kooboo.Sites.HtmlForm.FormManager.GetSubmitUrl(form, formsetting, context);
Dictionary <string, string> attributes = new Dictionary <string, string>(this.FormAttributes);
attributes["action"] = submiturl;
attributes["method"] = string.IsNullOrEmpty(formsetting.Method) ? "post" : formsetting.Method;
if (formsetting.AllowAjax)
{
attributes["onsubmit"] = "return false;";
}
string key = "kform_" + Lib.Security.ShortGuid.GetNewShortId();
/// append additional koobooform id.....
if (form.FormType == Models.FormType.KoobooForm)
{
attributes["id"] = key;
}
string opentag = Kooboo.Sites.Service.DomService.GenerateOpenTag(attributes, "form");
if (formsetting.IsSelfRefresh)
{
opentag = opentag + "<input type='hidden' name=\"" + Sites.HtmlForm.FormManager.FormUrlName + "\" value=\"" + context.Request.RawRelativeUrl + "\" />";
}
// If ajax, append the additional text here...
//opentag += JsString(key, formsetting.SuccessCallBack, formsetting.FailedCallBack);
string result = opentag + RenderHelper.Render(GetBodyTask(form.Body), context) + "</form>";
result += JsString(key, formsetting.SuccessCallBack, formsetting.FailedCallBack);
return(Task.FromResult(result));
}
//public ActionResult Display(decimal ID)
//{
// ViewBag.QuestionID = ID;
// var pview = RenderQuestion(ID);
// ViewBag.PartialView = pview;
// //return RedirectToAction(RenderQuestion(ID));
// return RedirectToAction("RenderQuestion", new { ID = ID });
// //return View("_Question");
//}
//public ActionResult Display(decimal ID)
//{
// return Display(ID, "false");
//}
//public ActionResult Display(decimal ID,bool criticalelement)
//{
// ViewBag.QuestionID = ID;
// ViewBag.DisplayLabel = true;
// ScreenViewer.API.Elements.QuestionController QC = new API.Elements.QuestionController();
// var actionResult = QC.GetScriptQuestion(ID);
// var response = actionResult as OkNegotiatedContentResult<Data.ScriptQuestion>;
// //Assert.IsNotNull(response);
// Data.ScriptQuestion theQuestion = response.Content;
// ViewBag.QuestionDisplay = SPutilities.ReplaceObjectsandQuestions(HttpContext.Session, theQuestion.QuestionText,true);
// ViewBag.QuestionID = theQuestion.ScriptQuestionID;
// ViewBag.ControlName = "SPQuestion_" + theQuestion.ScriptQuestionID;
// if (criticalelement)
// {
// ViewBag.ControlName += "_C";
// }
// string cresp = SessionControl.SessionManager.GetQuestionResponse(ID.ToString(), HttpContext.Session);
// ViewBag.ReturnType = theQuestion.ResponseType;
// ViewBag.AnswerRequired = theQuestion.AnswerRequired.Value ? "required" : string.Empty;
// switch (theQuestion.QuestionType)
// {
// case FREE_TEXT:
// ViewBag.CurrentResponse = cresp;
// ViewBag.ValidatorRegex = null;
// if (theQuestion.ScriptValidatorID != null && theQuestion.ScriptValidatorID != 0)
// {
// var result = QC.GetScriptTextValidator(theQuestion.ScriptValidatorID.Value);
// var ValidatorResponse = result as OkNegotiatedContentResult<Data.ScriptValidator>;
// Data.ScriptValidator scriptTextValidator = ValidatorResponse.Content;
// ViewBag.ValidatorRegex = scriptTextValidator.ValidatorRegex;
// ViewBag.ValidatorDesc = scriptTextValidator.ValidatorDesc;
// }
// switch (theQuestion.ResponseType)
// {
// case "Date":
// case "DateTime":
// case "Time":
// return PartialView("_DateTimeQuestion");
// case "Number":
// if (theQuestion.MinimumValue != null)
// {
// ViewBag.MinValue = theQuestion.MinimumValue;
// }
// if (theQuestion.MaximumValue != null)
// {
// ViewBag.MaxValue = theQuestion.MaximumValue;
// }
// return PartialView("_NumericQuestion");
// case "String":
// ViewBag.MaxLength = theQuestion.MaxLength;
// return PartialView("_TextQuestion");
// }
// break;
// case CONFIRM:
// ViewBag.CurrentResponse = cresp;
// ViewBag.Checked = cresp == "True" ? "Checked" : "";
// return PartialView("_ConfirmQuestion");
// case YES_NO:
// ViewBag.CurrentResponse = cresp;
// ViewBag.YesCheck = cresp == "Yes" ? "Checked" : "";
// ViewBag.NoCheck = cresp == "No" ? "Checked" : "";
// return PartialView("_YesNoQuestion");
// case PICK_ONE_ALT:
// case PICK_ONE:
// ViewBag.CurrentResponse = cresp == null ? null :cresp;
// if (!string.IsNullOrEmpty(theQuestion.DataObjectField))
// {
// }
// else
// {
// List<SelectListItem> pickList = CreateDOList(theQuestion.Choices);
// ViewBag.PickList = pickList;
// ViewBag.PickLength = pickList.Count;
// ViewBag.ControlID = "listquestion_" + theQuestion.ScriptQuestionID.ToString();
// return PartialView("_PickOneQuestion");
// }
// break;
// case PICK_MANY:
// ViewBag.CurrentResponse = cresp == null ? null : Regex.Split(cresp, ",").ToList();
// if (!string.IsNullOrEmpty(theQuestion.DataObjectField))
// {
// }
// else
// {
// List<SelectListItem> pickList = CreateDOList(theQuestion.Choices);
// ViewBag.PickList = pickList;
// ViewBag.PickLength = pickList.Count;
// ViewBag.ID = theQuestion.ScriptQuestionID.ToString();
// ViewBag.ControlID = "listquestion_" + theQuestion.ScriptQuestionID.ToString();
// return PartialView("_PickManyQuestion");
// }
// break;
// default:
// break;
// }
// return Content("Blah Blah");
//}
public ScreenViewer.Models.Elements.QuestionLayout RenderQuestionParts(decimal ID, bool criticalelement, ControllerContext ContCont)
{
ScreenViewer.Models.Elements.QuestionLayout questionLayout = new Models.Elements.QuestionLayout();
ViewBag.QuestionID = ID;
ViewBag.DisplayLabel = false;
ScreenViewer.API.Elements.QuestionController QC = new API.Elements.QuestionController();
var actionResult = QC.GetScriptQuestion(ID);
var response = actionResult as OkNegotiatedContentResult <Data.ScriptQuestion>;
//Assert.IsNotNull(response);
Data.ScriptQuestion theQuestion = response.Content;
ViewBag.QuestionDisplay = SPutilities.ReplaceObjectsandQuestions(ContCont.HttpContext.Session, theQuestion.QuestionText, true);
ViewBag.QuestionID = theQuestion.ScriptQuestionID;
ViewBag.ControlName = "SPQuestion_" + theQuestion.ScriptQuestionID;
if (criticalelement)
{
ViewBag.ControlName += "_C";
}
string cresp = SessionControl.SessionManager.GetQuestionResponse(ID.ToString(), ContCont.HttpContext.Session);
if (string.IsNullOrEmpty(cresp) && !string.IsNullOrEmpty(theQuestion.KeyCodes))
{
if (theQuestion.KeyCodes.StartsWith("DO."))
{
string[] holdKeyCode = theQuestion.KeyCodes.Split('.');
string dataObject = holdKeyCode[1];
ScreenViewer.Models.DataObjects ScriptDataObject = (ScreenViewer.Models.DataObjects)SessionControl.SessionManager.GetDataObject(ContCont.HttpContext.Session, dataObject);
if (ScriptDataObject != null)
{
foreach (var detail in ScriptDataObject.Details)
{
if (detail.DetailName == holdKeyCode[2] && detail.DetailValue != null)
{
cresp = detail.DetailValue.ToString();
}
}
}
}
}
ViewBag.ReturnType = theQuestion.ResponseType;
try
{
ViewBag.AnswerRequired = ((bool)theQuestion.AnswerRequired) ? "required" : string.Empty;
}
catch
{
ViewBag.AnswerRequired = string.Empty;
}
questionLayout.QuestionLabelText = ViewBag.QuestionDisplay;//theQuestion.QuestionText;
switch (theQuestion.QuestionType)
{
case FREE_TEXT:
ViewBag.Type = "text";
ViewBag.CurrentResponse = cresp;
ViewBag.ValidatorRegex = null;
if (theQuestion.QuestionDesc.Substring(theQuestion.QuestionDesc.Length - 1) == "$")
{
ViewBag.Type = "password";
}
if (theQuestion.ScriptValidatorID != null && theQuestion.ScriptValidatorID != 0)
{
var result = QC.GetScriptTextValidator(theQuestion.ScriptValidatorID.Value);
var ValidatorResponse = result as OkNegotiatedContentResult <Data.ScriptValidator>;
Data.ScriptValidator scriptTextValidator = ValidatorResponse.Content;
ViewBag.ValidatorRegex = scriptTextValidator.ValidatorRegex;
ViewBag.ValidatorDesc = scriptTextValidator.ValidatorDesc;
}
switch (theQuestion.ResponseType)
{
case "Date":
case "DateTime":
case "Time":
questionLayout.QuestionHTML = RenderHelper.RenderViewToString(ContCont, "~/Views/Question/_DateTimeQuestion.cshtml", theQuestion, ViewData);
break;
case "Number":
if (theQuestion.MinimumValue != null)
{
ViewBag.MinValue = theQuestion.MinimumValue;
}
if (theQuestion.MaximumValue != null)
{
ViewBag.MaxValue = theQuestion.MaximumValue;
}
questionLayout.QuestionHTML = RenderHelper.RenderViewToString(ContCont, "~/Views/Question/_NumericQuestion.cshtml", theQuestion, ViewData);
break;
case "String":
ViewBag.MaxLength = theQuestion.MaxLength;
questionLayout.QuestionHTML = RenderHelper.RenderViewToString(ContCont, "~/Views/Question/_TextQuestion.cshtml", theQuestion, ViewData);
break;
}
break;
case CONFIRM:
ViewBag.CurrentResponse = cresp;
ViewBag.Checked = cresp == "True" ? "Checked" : "";
questionLayout.QuestionHTML = RenderHelper.RenderViewToString(ContCont, "~/Views/Question/_ConfirmQuestion.cshtml", theQuestion, ViewData);
break;
case YES_NO:
ViewBag.CurrentResponse = cresp;
ViewBag.YesCheck = cresp == "Yes" ? "Checked" : "";
ViewBag.NoCheck = cresp == "No" ? "Checked" : "";
questionLayout.QuestionHTML = RenderHelper.RenderViewToString(ContCont, "~/Views/Question/_YesNoQuestion.cshtml", theQuestion, ViewData);
break;
case PICK_ONE_ALT:
case PICK_ONE:
ViewBag.CurrentResponse = cresp == null ? null : cresp;
ViewBag.QuestionType = theQuestion.QuestionType;
ViewBag.MaxLength = theQuestion.MaxLength;
if (!string.IsNullOrEmpty(theQuestion.DataObjectField))
{
List <string> displayItems = Regex.Split(theQuestion.DODisplayColumns, "~").ToList();
if (displayItems.Count > 1)
{
DataTable listtable = CreateObjectSelectList(theQuestion, ContCont.HttpContext.Session);
ViewBag.ValueColumn = theQuestion.DOValueColumn;
ViewBag.DataTable = listtable;
ViewBag.ControlID = "gridquestion_" + theQuestion.ScriptQuestionID.ToString();
ViewBag.OID = theQuestion.ScriptQuestionID.ToString();
questionLayout.QuestionHTML = RenderHelper.RenderViewToString(ContCont, "~/Views/Question/_ObjectSelector.cshtml", theQuestion, ViewData);
}
else
{
List <SelectListItem> pickList = CreateDobList(theQuestion, ContCont.HttpContext.Session);
ViewBag.PickList = pickList;
ViewBag.PickLength = pickList.Count;
ViewBag.ControlID = "listquestion_" + theQuestion.ScriptQuestionID.ToString();
questionLayout.QuestionHTML = RenderHelper.RenderViewToString(ContCont, "~/Views/Question/_PickOneQuestion.cshtml", theQuestion, ViewData);
break;
}
}
else if (theQuestion.ScriptLookupID != null && theQuestion.ScriptLookupID.Value != 0.0M)
{
List <SelectListItem> pickList = CreateLookupList(theQuestion, ContCont.HttpContext.Session);
ViewBag.PickList = pickList;
ViewBag.PickLength = pickList.Count;
ViewBag.ControlID = "listquestion_" + theQuestion.ScriptQuestionID.ToString();
questionLayout.QuestionHTML = RenderHelper.RenderViewToString(ContCont, "~/Views/Question/_PickOneQuestion.cshtml", theQuestion, ViewData);
break;
}
else
{
List <SelectListItem> pickList = CreateDOList(theQuestion.Choices);
ViewBag.PickList = pickList;
ViewBag.PickLength = pickList.Count;
ViewBag.ControlID = "listquestion_" + theQuestion.ScriptQuestionID.ToString();
questionLayout.QuestionHTML = RenderHelper.RenderViewToString(ContCont, "~/Views/Question/_PickOneQuestion.cshtml", theQuestion, ViewData);
break;
}
break;
case PICK_MANY:
ViewBag.CurrentResponse = cresp == null ? null : Regex.Split(cresp, ",").ToList();
ViewBag.CurrentResponse = cresp == null ? null : Regex.Split(cresp, "~").ToList();
ViewBag.MaxLength = theQuestion.MaxLength;
//string pmResponse = string.Empty;
//List<string> holdList = cresp == null ? null : Regex.Split(cresp, ",").ToList();
//if (holdList != null && holdList.Count > 0)
//{
// foreach (var item in holdList)
// {
// pmResponse = string.Format("{0}'{1}',", pmResponse, item);
// }
// pmResponse = pmResponse.TrimEnd(',');
// ViewBag.CurrentResponse = System.Web.HttpUtility.JavaScriptStringEncode(pmResponse);
//}
//else
// ViewBag.CurrentResponse = pmResponse;
List <string> displayItems2 = null;
if (theQuestion.DODisplayColumns != null)
{
displayItems2 = Regex.Split(theQuestion.DODisplayColumns, "~").ToList();
}
if (!string.IsNullOrEmpty(theQuestion.DataObjectField))
{
if (displayItems2.Count > 1)
{
DataTable listtable = CreateObjectSelectList(theQuestion, ContCont.HttpContext.Session);
ViewBag.DataTable = listtable;
ViewBag.ControlID = "gridquestion_" + theQuestion.ScriptQuestionID.ToString();
questionLayout.QuestionHTML = RenderHelper.RenderViewToString(ContCont, "~/Views/Question/_ObjectSelector.cshtml", theQuestion, ViewData);
}
else
{
List <SelectListItem> pickList = CreateDobList(theQuestion, ContCont.HttpContext.Session);
ViewBag.PickList = pickList;
ViewBag.PickLength = pickList.Count;
ViewBag.ID = theQuestion.ScriptQuestionID.ToString();
ViewBag.ControlID = "listquestion_" + theQuestion.ScriptQuestionID.ToString();
questionLayout.QuestionHTML = RenderHelper.RenderViewToString(ContCont, "~/Views/Question/_PickManyQuestion.cshtml", theQuestion, ViewData);
}
}
else if (theQuestion.ScriptLookupID != null && theQuestion.ScriptLookupID.Value != 0.0M)
{
List <SelectListItem> pickList = CreateLookupList(theQuestion, ContCont.HttpContext.Session);
ViewBag.PickList = pickList;
ViewBag.PickLength = pickList.Count;
ViewBag.ID = theQuestion.ScriptQuestionID.ToString();
ViewBag.ControlID = "listquestion_" + theQuestion.ScriptQuestionID.ToString();
questionLayout.QuestionHTML = RenderHelper.RenderViewToString(ContCont, "~/Views/Question/_PickManyQuestion.cshtml", theQuestion, ViewData);
}
else
{
List <SelectListItem> pickList = CreateDOList(theQuestion.Choices);
ViewBag.PickList = pickList;
ViewBag.PickLength = pickList.Count;
ViewBag.ID = theQuestion.ScriptQuestionID.ToString();
ViewBag.ControlID = "listquestion_" + theQuestion.ScriptQuestionID.ToString();
questionLayout.QuestionHTML = RenderHelper.RenderViewToString(ContCont, "~/Views/Question/_PickManyQuestion.cshtml", theQuestion, ViewData);
break;
}
break;
default:
break;
}
return(questionLayout);
}
private string GetControlID(string context)
{
return(context + RenderHelper.GetColumnGlobalIndex(Column));
}
public static void RenderBasics()
{
if (Global.Player.IsDead)
{
return;
}
if (MenuConfig.FleeMode.Active)
{
var spot = WallExtension.GetBestWallHopPos(Global.Player.ServerPosition, 275);
if (!spot.IsZero)
{
Render.WorldToScreen(spot.Extend(Global.Player.ServerPosition, 65), out var startPointVector2);
Render.WorldToScreen(spot, out var endPointVector2);
Render.Line(startPointVector2, endPointVector2, Color.Orange);
Render.Circle(spot, 50, (uint)MenuConfig.Drawings["Segments"].Value, Color.White);
}
}
if (MenuConfig.Drawings["Mouse"].Enabled && Global.Orbwalker.Mode != OrbwalkingMode.None)
{
if (!SpellConfig.Q.Ready && Extensions.CurrentQCount == 1)
{
return;
}
var temp = Global.Orbwalker.GetOrbwalkingTarget();
if (temp != null && temp.IsHero && temp.Distance(Global.Player) > Global.Player.AttackRange - 100)
{
var pos = Global.Player.ServerPosition.Extend(temp.ServerPosition, 450);
Render.Circle(pos, 200, (uint)MenuConfig.Drawings["Segments"].Value, Color.Yellow);
Render.WorldToScreen(pos, out var posV2);
Render.Text("Put Mouse Here", new Vector2(posV2.X - 50, posV2.Y), RenderTextFlags.Center, Color.White);
}
}
if (MenuConfig.Drawings["Pattern"].Enabled)
{
Render.WorldToScreen(Global.Player.Position, out var playerV2);
if (MenuConfig.BurstMode.Active)
{
RenderHelper.RenderArrowFromPlayer(Global.TargetSelector.GetSelectedTarget());
Render.Text("PATTERN: " + Enums.BurstPattern, new Vector2(playerV2.X - 65, playerV2.Y + 30), RenderTextFlags.Center, Color.Aqua);
}
switch (Global.Orbwalker.Mode)
{
case OrbwalkingMode.Mixed:
RenderHelper.RenderArrowFromPlayer(Global.TargetSelector.GetTarget(Extensions.EngageRange + 800));
Render.Text("PATTERN: " + Enums.Current, new Vector2(playerV2.X - 65, playerV2.Y + 30), RenderTextFlags.Center, Color.Aqua);
break;
}
}
if (MenuConfig.Drawings["Engage"].Enabled)
{
if (Extensions.AllIn || MenuConfig.BurstMode.Active)
{
Render.Circle(Global.Player.Position, Extensions.FlashRange(), (uint)MenuConfig.Drawings["Segments"].Value, Color.Yellow);
}
else
{
Render.Circle(Global.Player.Position, Extensions.EngageRange, (uint)MenuConfig.Drawings["Segments"].Value, Color.White);
}
}
if (MenuConfig.Drawings["R2"].Enabled && SpellConfig.R2.Ready && Enums.UltimateMode == UltimateMode.Second)
{
Render.Circle(Global.Player.Position, SpellConfig.R2.Range, (uint)MenuConfig.Drawings["Segments"].Value, Color.OrangeRed);
}
}
public override void DepthExtractor(GameTime gt, IObject obj, ref Matrix View, ref Matrix projection, RenderHelper render)
{
///no shadow
}
protected override void Draw(GameTime gameTime, RenderHelper render)
{
base.Draw(gameTime, render);
render.RenderTextComplete("Particle System Integration; Snow and Smoke, check DPFS SAMPLES", new Vector2(10, 15), Color.White, Matrix.Identity);
render.RenderTextComplete("Left Mouse Buttom to throw balls that emits smoke", new Vector2(10, 35), Color.White, Matrix.Identity);
}
/// <summary>
/// Presents the light map to the current render target
/// </summary>
private void LightMapPresent()
{
RenderHelper.DrawTextureToTarget(this.mMap, this.mLightMapSize, BlendTechnique.Multiply);
}
public void ResolveLightMap(RenderHelper render)
{
render.PopRenderTarget();
}
/// <summary>
/// Executes the technic.
/// </summary>
/// <param name="gameTime"></param>
/// <param name="render">The render.</param>
/// <param name="world">The world.</param>
protected override void ExecuteTechnic(GameTime gameTime, RenderHelper render, IWorld world)
{
Draw(gameTime, world, render);
}
public void DrawLights(GameTime gameTime, IWorld world, IDeferredGBuffer deferredGBuffer, RenderHelper render)
{
render.Clear(Color.Transparent, ClearOptions.Target);
render.PushBlendState(_lightAddBlendState);
render.PushDepthStencilState(DepthStencilState.None);
DrawDirectionalLight(world.CameraManager.ActiveCamera, world.Lights, deferredGBuffer, render);
DrawPointLight(world.CameraManager.ActiveCamera, world.Lights, deferredGBuffer, render);
DrawnSpotLight(world.CameraManager.ActiveCamera, world.Lights, deferredGBuffer, render);
render.PopBlendState();
render.PopDepthStencilState();
}
public string Execute(RenderContext context, Dictionary <string, string> Paras)
{
if (Paras != null && Paras.Count() > 0)
{
Dictionary <string, string> datavalue = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var item in Paras)
{
if (item.Key.ToLower() != "name" && item.Key.ToLower() != "id")
{
datavalue.Add(item.Key, item.Value);
}
}
if (datavalue.Count() > 0)
{
context.DataContext.Push(datavalue);
}
}
string layoutNameOrId = GetLayoutNameOrId(Paras);
string layoutbody = null;
if (!string.IsNullOrEmpty(layoutNameOrId))
{
layoutbody = GetSourceFromDb(context, layoutNameOrId);
if (!string.IsNullOrEmpty(layoutbody))
{
List <IRenderTask> renderplan;
EvaluatorOption options = new EvaluatorOption();
options.RenderUrl = false;
options.RenderHeader = true;
Guid sourceid = Lib.Security.Hash.ComputeHashGuid(layoutbody); // GetLayoutGuid(layoutNameOrId);
if (context.Request.Channel == RequestChannel.InlineDesign)
{
layoutbody = DomService.ApplyKoobooId(layoutbody);
options.RequireBindingInfo = true;
renderplan = RenderEvaluator.Evaluate(layoutbody, options);
}
else
{
SiteDb sitedb;
if (context.WebSite == null)
{
var site = new WebSite()
{
Name = "__Koobootemp"
};
sitedb = site.SiteDb();
}
else
{
sitedb = context.WebSite.SiteDb();
}
renderplan = Cache.RenderPlan.GetOrAddRenderPlan(sitedb, sourceid, () => RenderEvaluator.Evaluate(layoutbody, options));
}
return(RenderHelper.Render(renderplan, context));
}
}
return(null);
}
protected override void Draw(GameTime gameTime, RenderHelper render)
{
base.Draw(gameTime, render);
}
private void RenderImageAndText(Graphics g, Rectangle captionRect)
{
Rectangle imageRect = Rectangle.Empty;
Rectangle textRect = Rectangle.Empty;
int bordWidth = base.BorderWidth;
int imageWidth = CaptionHeight - 6;
StringFormat sf = new StringFormat();
sf.FormatFlags = StringFormatFlags.NoWrap;
sf.Trimming = StringTrimming.EllipsisCharacter;
bool rightToLeft = base.RightToLeft == RightToLeft.Yes;
bool drawImage = Owner.ImageStyle == CaptionImageStyle.Draw ||
Owner.ImageStyle == CaptionImageStyle.Image;
if (rightToLeft)
{
sf.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
}
if (drawImage)
{
imageRect = new Rectangle(
bordWidth, captionRect.Y + 3, imageWidth, imageWidth);
}
else
{
imageRect.X = bordWidth - 3;
}
textRect = new Rectangle(
imageRect.Right + 3,
captionRect.Y,
captionRect.Width - (imageRect.Right + 3) - bordWidth,
captionRect.Height);
if (rightToLeft)
{
imageRect.X = captionRect.Right - imageRect.Right;
textRect.X = captionRect.Right - textRect.Right;
}
sf.LineAlignment = StringAlignment.Center;
switch (TextAlign)
{
case ContentAlignment.BottomCenter:
case ContentAlignment.MiddleCenter:
case ContentAlignment.TopCenter:
sf.Alignment = StringAlignment.Center;
break;
case ContentAlignment.BottomLeft:
case ContentAlignment.MiddleLeft:
case ContentAlignment.TopLeft:
sf.Alignment = StringAlignment.Near;
break;
case ContentAlignment.BottomRight:
case ContentAlignment.MiddleRight:
case ContentAlignment.TopRight:
sf.Alignment = StringAlignment.Far;
break;
}
if (!string.IsNullOrEmpty(base.Text))
{
using (Brush brush = new SolidBrush(ColorTable.CaptionFore))
{
g.DrawString(
base.Text,
CaptionFont,
brush,
textRect,
sf);
}
}
if (drawImage)
{
if (Owner.ImageStyle == CaptionImageStyle.Image)
{
Image image = _isExpanded ?
Owner.ExpandImage : Owner.CollapseImage;
if (image != null)
{
g.DrawImage(
image,
imageRect,
0,
0,
image.Width,
image.Height,
GraphicsUnit.Pixel);
}
}
else
{
ArrowDirection direction = _isExpanded ?
ArrowDirection.Up : ArrowDirection.Down;
using (SmoothingModeGraphics sg = new SmoothingModeGraphics(g))
{
using (Brush brush = new SolidBrush(ColorTable.CaptionFore))
{
RenderHelper.RenderArrowInternal(
g,
imageRect,
direction,
brush);
}
}
}
}
}
public override void BasicDraw(GameTime gt, IObject obj, ref Matrix view, ref Matrix projection, IList <ILight> lights, RenderHelper render, Plane?clippingPlane, bool useAlphaBlending = false)
{
///no reflection refraction
}
protected override WebControl CreateEditModeControlCore()
{
//$('#Vertical_v1_50539512_MainLayoutEdit_xaf_l19_PersianDatePickerScheduledOnDateTime_I').data('datepicker').getDate()
Calendars = new Dictionary <string, System.Globalization.Calendar>();
Calendars["EN"] = new GregorianCalendar();
Calendars["FA"] = TralusDateTime.AltCalendar;
var datePickePersianrId = string.Format("DatePickerPersian{0}", PropertyName);
var datePickerGregorianId = string.Format("DatePickerGregorian{0}", PropertyName);
var clockPickerId = string.Format("ClockPicker{0}", propertyName);
var comboBoxCalendarId = string.Format("ComboBoxCalendar{0}", propertyName);
var comboBoxTimeZoneId = string.Format("ComboBoxTimeZone{0}", propertyName);
var gregorianGotFocusGuid = System.Guid.NewGuid().ToString();
var gregorianGotFocusValueChangedGuid = System.Guid.NewGuid().ToString();
var persianGotFocusGuid = System.Guid.NewGuid().ToString();
var persianGotValueChangedGuid = System.Guid.NewGuid().ToString();
var clockPickerGotFocusGuid = System.Guid.NewGuid().ToString();
var clockPickerGotValueChangedGuid = System.Guid.NewGuid().ToString();
datePickerGregorian = RenderHelper.CreateASPxTextBox();
datePickerGregorian.ID = datePickerGregorianId;
datePickerGregorian.Validation += TralusDateTimeControlGregorian_Validation;
datePickerGregorian.ValidationSettings.EnableCustomValidation = true;
datePickerGregorian.ValidateRequestMode = System.Web.UI.ValidateRequestMode.Enabled;
datePickerGregorian.ValidationSettings.ValidateOnLeave = true;
datePickerGregorian.CssClass = "input-date-picker datepicker-ltr";
datePickerGregorian.SetClientSideEventHandler("GotFocus", string.Format(" /*{0}*/ function(s, e) {{ document.isMenuClicked = false; }} /*{0}*/", gregorianGotFocusGuid));
datePickerGregorian.SetClientSideEventHandler("ValueChanged", string.Format(" /*{0}*/ function(s,e) {{ window.setTimeout(function() {{ if(!document.isMenuClicked) {{ RaiseXafCallback(globalCallbackControl, '', '', '', false); }}document.isMenuClicked = false;}}, 500); }} /*{0}*/", gregorianGotFocusValueChangedGuid));
datePickerGregorian.ClientSideEvents.Init = string.Format("function Init(s,e) {{ var input = s.GetInputElement(); jQuery(input).datepicker({{ autoclose: true, language: 'en', rtl: false, weekStart: 1, calendar: 'gregorian', todayBtn: true, format:'yyyy/mm/dd' }}); }}");
datePickerPersian = RenderHelper.CreateASPxTextBox();
datePickerPersian.ID = datePickePersianrId;
datePickerPersian.Validation += TralusDateTimeControlPersian_Validation;
datePickerPersian.ValidationSettings.EnableCustomValidation = true;
datePickerPersian.ValidateRequestMode = System.Web.UI.ValidateRequestMode.Enabled;
datePickerPersian.ValidationSettings.ValidateOnLeave = true;
datePickerPersian.CssClass = "input-date-picker datepicker-rtl";
datePickerPersian.SetClientSideEventHandler("GotFocus", string.Format("/*{0}*/ function(s, e) {{document.isMenuClicked = false; }} /*{0}*/", persianGotFocusGuid));
datePickerPersian.SetClientSideEventHandler("ValueChanged", string.Format(" /*{0}*/ function(s,e) {{ var selectedDate = $('#'+s.GetInputElement().id).data('datepicker').getDate(); window.setTimeout(function() {{ if(!document.isMenuClicked) {{ RaiseXafCallback(globalCallbackControl, '', selectedDate, '', false); }} document.isMenuClicked = false;}}, 500); }} /*{0}*/", persianGotValueChangedGuid));
datePickerPersian.ClientSideEvents.Init = string.Format("function Init(s,e) {{ var input = s.GetInputElement(); jQuery(input).datepicker({{ autoclose: true, language: 'fa', rtl: false, weekStart: 1, calendar: 'persian', todayBtn: true, format:'yyyy/mm/dd' }}); }}");
comboBoxCalendar = RenderHelper.CreateASPxComboBox();
comboBoxCalendar.ID = comboBoxCalendarId;
comboBoxCalendar.Items.Add("EN", "EN");
comboBoxCalendar.Items.Add("FA", "FA");
comboBoxCalendar.SelectedIndex = 0;
comboBoxCalendar.ClientSideEvents.SelectedIndexChanged = string.Format("function(combo) {{ {0}SelectedCalendar(combo.lastSuccessValue); }}", PropertyName);
comboBoxCalendar.ClientSideEvents.Init = string.Format("function OnInit(s,e){{ {0}SelectedCalendar(s.lastSuccessValue); }}", PropertyName);
var table = RenderHelper.CreateTable();
var row = new TableRow();
var tableCellDatePickerPersian = new TableCell();
var tableCellDatePickerGregorian = new TableCell();
var tableCellComboBoxCalendar = new TableCell();
tableCellDatePickerPersian.Controls.Add(datePickerPersian);
tableCellDatePickerPersian.Attributes.Add("data-bind", string.Format("visible: {0}SelectedCalendar() === 'FA'", PropertyName));
tableCellDatePickerGregorian.Controls.Add(datePickerGregorian);
tableCellDatePickerGregorian.Attributes.Add("data-bind", string.Format("visible: {0}SelectedCalendar() === 'EN'", PropertyName));
tableCellComboBoxCalendar.Controls.Add(comboBoxCalendar);
var selectedModelContainer = RenderHelper.CreateASPxTextBox();
selectedModelContainer.ClientSideEvents.Init = string.Format("function OnInit(s,e){{ function {0}DateTimeViewModel () {{ {0}SelectedCalendar = ko.observable('EN'); }}; var input = s.GetInputElement(); ko.applyBindings(new {0}DateTimeViewModel(),input); ko.applyBindings({{}},jQuery('[id*=dvi{0}]')[0]); }}", PropertyName);
var tableCellSelectedModelContainer = new TableCell();
tableCellSelectedModelContainer.Controls.Add(selectedModelContainer);
tableCellSelectedModelContainer.Style.Add("display", "none");
row.Cells.Add(tableCellSelectedModelContainer);
row.Cells.Add(tableCellComboBoxCalendar);
row.Cells.Add(tableCellDatePickerPersian);
row.Cells.Add(tableCellDatePickerGregorian);
table.Rows.Add(row);
table.Style.Add("width", "auto");
table.Style.Add("border-spacing", "1px");
UpdateControlsValue();
return(table);
}
public override void Draw(Microsoft.Xna.Framework.Graphics.Texture2D ImageToProcess, RenderHelper rHelper, Microsoft.Xna.Framework.GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
{
effect.Parameters["extrart"].SetValue(rHelper[PrincipalConstants.extra1RT]);
effect.Parameters["backtex"].SetValue(BackGroundTexture);
if (useFloatBuffer)
{
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, effect, GraphicInfo.FullScreenRectangle, SamplerState.PointClamp);
}
else
{
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, effect, GraphicInfo.FullScreenRectangle, GraphicInfo.SamplerState);
}
}
protected void DrawPointLight(ICamera camera, IList <ILight> lights, IDeferredGBuffer DeferredGBuffer, RenderHelper render)
{
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
PointProjection.SetValue(camera.Projection);
PointView.SetValue(camera.View);
PointcameraPosition.SetValue(camera.Position);
PointInvertViewProjection.SetValue(Matrix.Invert(camera.ViewProjection));
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Point && item.Enabled == true)
{
PointLightPE pl = item as PointLightPE;
Matrix sphereWorldMatrix = Matrix.CreateScale(pl.LightRadius) * Matrix.CreateTranslation(pl.LightPosition);
ContainmentType ct = ContainmentType.Contains;
if (cullPointLight)
{
ct = camera.BoundingFrustum.Contains(new BoundingSphere(pl.LightPosition, pl.LightRadius));
}
if (ct == ContainmentType.Contains || ct == ContainmentType.Intersects)
{
PointWorld.SetValue(sphereWorldMatrix);
PointlightPosition.SetValue(pl.LightPosition);
PointColor.SetValue(pl.Color.ToVector3());
PointlightRadius.SetValue(pl.LightRadius);
PointlightIntensity.SetValue(pl.LightIntensity);
Pointquadratic.SetValue(pl.UsePointLightQuadraticAttenuation);
float cameraToCenter = Vector3.Distance(camera.Position, pl.LightPosition);
if (cameraToCenter < pl.LightRadius + camera.NearPlane)
{
render.PushRasterizerState(RasterizerState.CullClockwise);
}
else
{
render.PushRasterizerState(RasterizerState.CullCounterClockwise);
}
render.RenderBatch(sphereModel.GetBatchInformation(0)[0], pointLightEffect);
render.PopRasterizerState();
}
}
}
render.SetSamplerState(s2, 2);
}
/// <summary>
/// Ends the forward pass.
/// Clean Up
/// </summary>
/// <returns></returns>
public Texture2D EndForwardPass(RenderHelper render)
{
render.PopRenderTarget();
return(target);
}
protected override void Draw(GameTime gameTime, RenderHelper render)
{
base.Draw(gameTime, render);
render.RenderTextComplete("Explosion with particles", new Vector2(20, 15), Color.White, Matrix.Identity);
render.RenderTextComplete("Press Space", new Vector2(20, 35), Color.White, Matrix.Identity);
}
protected override void Draw(Microsoft.Xna.Framework.GameTime gameTime, RenderHelper render)
{
}
protected void DrawDirectionalLight(ICamera camera, IList <ILight> lights, IDeferredGBuffer DeferredGBuffer, RenderHelper render)
{
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
DirectionalcameraPosition.SetValue(camera.Position);
DirectionalInvertViewProjection.SetValue(Matrix.Invert(camera.ViewProjection));
DirectionalhalfPixel.SetValue(ginfo.HalfPixel);
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Directional && item.Enabled == true)
{
PloobsEngine.Light.DirectionalLightPE dl = item as PloobsEngine.Light.DirectionalLightPE;
DirectionallightDirection.SetValue(dl.LightDirection);
DirectionalColor.SetValue(dl.Color.ToVector3());
DirectionallightIntensity.SetValue(dl.LightIntensity);
render.RenderFullScreenQuadVertexPixel(directionalLightEffect);
}
}
render.SetSamplerState(s2, 2);
}
protected void DrawnSpotLight(ICamera camera, IList <ILight> lights, IDeferredGBuffer DeferredGBuffer, RenderHelper render)
{
render.PushRasterizerState(RasterizerState.CullNone);
render.PushDepthStencilState(DepthStencilState.None);
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
spotLightEffect.Parameters["View"].SetValue(camera.View);
spotLightEffect.Parameters["Projection"].SetValue(camera.Projection);
spotLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
spotLightEffect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(camera.View * camera.Projection));
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Spot && item.Enabled == true)
{
SpotLightPE sl = item as SpotLightPE;
spotLightEffect.Parameters["lightPosition"].SetValue(sl.Position);
spotLightEffect.Parameters["lightDirection"].SetValue(sl.Direction);
spotLightEffect.Parameters["lightRadius"].SetValue(sl.LightRadius);
spotLightEffect.Parameters["lightDecayExponent"].SetValue(sl.ConeDecay);
spotLightEffect.Parameters["Color"].SetValue(sl.Color.ToVector3());
spotLightEffect.Parameters["lightAngleCosine"].SetValue(sl.LightAngleCosine);
spotLightEffect.Parameters["lightIntensity"].SetValue(sl.LightIntensity);
render.RenderFullScreenQuadVertexPixel(spotLightEffect);
}
}
render.PopDepthStencilState();
render.PopRasterizerState();
render.SetSamplerState(s2, 2);
}
protected override void EndDraw(Microsoft.Xna.Framework.GameTime gt, RenderHelper render, Engine.GraphicInfo ginfo)
{
manager.EndDraw();
render.ResyncStates();
}
private void CustomPopUp_Initialized(object sender, EventArgs e)
{
RenderHelper.ChangeRenderModeToSoftware(sender);
}
public void SetLightMap(RenderHelper render)
{
render.PushRenderTarget(lightRT);
}
/// <summary>
/// Draws the specified game time.
/// </summary>
/// <param name="gameTime">The game time.</param>
/// <param name="world">The world.</param>
/// <param name="render">The render.</param>
protected void Draw(GameTime gameTime, IWorld world, RenderHelper render)
{
Matrix view = world.CameraManager.ActiveCamera.View;
Matrix projection = world.CameraManager.ActiveCamera.Projection;
world.Culler.StartFrame(ref view, ref projection, world.CameraManager.ActiveCamera.BoundingFrustum);
List <IObject> AllnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(null);
List <IObject> DeferrednotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.DEFERRED);
List <IObject> ForwardnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.FORWARD);
if (desc.OrderAllObjectsBeforeDraw != null)
{
AllnotCulledObjectsList = desc.OrderAllObjectsBeforeDraw(AllnotCulledObjectsList);
}
if (desc.OrderDeferredObjectsBeforeDraw != null)
{
DeferrednotCulledObjectsList = desc.OrderDeferredObjectsBeforeDraw(DeferrednotCulledObjectsList);
}
if (desc.OrderForwardObjectsBeforeDraw != null)
{
ForwardnotCulledObjectsList = desc.OrderForwardObjectsBeforeDraw(ForwardnotCulledObjectsList);
}
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures();
deferredGBuffer.PreDrawScene(gameTime, world, render, ginfo, AllnotCulledObjectsList);
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures();
deferredGBuffer.SetGBuffer(render);
deferredGBuffer.ClearGBuffer(render);
deferredGBuffer.DrawScene(gameTime, world, render, ginfo, DeferrednotCulledObjectsList);
deferredGBuffer.ResolveGBuffer(render);
render[PrincipalConstants.DephRT] = deferredGBuffer[GBufferTypes.DEPH];
render[PrincipalConstants.normalRt] = deferredGBuffer[GBufferTypes.NORMAL];
render.DettachBindedTextures();
render.ValidateSamplerStates();
deferredLightMap.SetLightMap(render);
deferredLightMap.DrawLights(gameTime, world, deferredGBuffer, render);
deferredLightMap.ResolveLightMap(render);
render[PrincipalConstants.lightRt] = deferredLightMap[DeferredLightMapType.LIGHTMAP];
render.DettachBindedTextures(5);
render.ValidateSamplerStates();
render.PushRenderTarget(scenerender);
render.Clear(desc.BackGroundColor);
foreach (IObject item in AllnotCulledObjectsList)
{
if (item.Material.IsVisible)
{
item.Material.PosDrawnPhase(gameTime, item, world.CameraManager.ActiveCamera, world.Lights, render);
}
}
render.DettachBindedTextures(3);
render.ValidateSamplerStates();
if (world.PhysicWorld.isDebugDraw)
{
world.PhysicWorld.iDebugDrawn(render, gameTime, world.CameraManager.ActiveCamera);
}
if (world.ParticleManager != null)
{
world.ParticleManager.iDraw(gameTime, world.CameraManager.ActiveCamera.View, world.CameraManager.ActiveCamera.Projection, render);
render.ResyncStates();
render.SetSamplerStates(ginfo.SamplerState);
}
render.DettachBindedTextures(6);
render.ValidateSamplerStates();
render.RenderPosWithDepthComponents(gameTime, ref view, ref projection);
render.DettachBindedTextures(6);
render.ValidateSamplerStates();
render[PrincipalConstants.colorRT] = scenerender;
render[PrincipalConstants.normalRt] = deferredGBuffer[GBufferTypes.NORMAL];
render[PrincipalConstants.lightRt] = deferredLightMap[DeferredLightMapType.LIGHTMAP];
render[PrincipalConstants.DephRT] = deferredGBuffer[GBufferTypes.DEPH];
render[PrincipalConstants.extra1RT] = deferredGBuffer[GBufferTypes.Extra1];
render[PrincipalConstants.CurrentImage] = render[PrincipalConstants.CombinedImage] = render.PopRenderTargetAsSingleRenderTarget2D();
for (int i = 0; i < PostEffects.Count; i++)
{
if (PostEffects[i].Enabled)
{
render.PushRenderTarget(PostEffectTarget);
render.Clear(Color.Black);
PostEffects[i].Draw(render[PrincipalConstants.CurrentImage], render, gameTime, ginfo, world, true);
Texture2D tex = render.PopRenderTarget()[0].RenderTarget as Texture2D;
render[PrincipalConstants.CurrentImage] = tex;
SwapTargetBuffers();
}
}
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures(6);
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
}
public override void Draw(Renderer renderer)
{
if (!isVisible)
{
return;
}
Vector2 posold = position;
if (ShouldOffset)
{
Position = Position + Settings.GameOffset * Settings.GameScale;
}
//bg
if (BGAsColor)
{
renderer.Draw(GraphicsEngine.pixel, new Rectangle((int)position.X, (int)position.Y, (int)Size.X, (int)Size.Y), BackgroundColor);
}
else
{
RenderHelper.SmartDrawRectangle(Texture, 5, (int)position.X, (int)position.Y, (int)Size.X, (int)Size.Y, BackgroundColor,
renderer);
}
#region ScissorsInit
float x = position.X < 0 ? 0 : position.X;
float y = position.Y < 0 ? 0 : position.Y;
float w = size.X < 0 ? 0 : size.X;
float h = size.Y < 0 ? 0 : size.Y;
if (x > Main.WindowWidth)
{
x = Main.WindowWidth;
}
if (y > Main.WindowHeight)
{
y = Main.WindowHeight;
}
if (x + w > Main.WindowWidth)
{
w = Main.WindowWidth - x;
}
if (y + h > Main.WindowHeight)
{
h = Main.WindowHeight - y;
}
#endregion
renderer.SetScissorRectangle(x, y, w, h, false);
//selection
if (SelectionStart != -1 && SelectionLength != 0)
{
int min = Math.Min(SelectionStart + SelectionLength, selectionStart);
int max = min + Math.Abs(SelectionLength);
var sc = getCoordForCursor(min);
int sci = (int)((sc.Y + TextOffset.Y) / SizePerOneSymbol.Y);
int scj = (int)((sc.X + TextOffset.X) / SizePerOneSymbol.X);
if (scj < 0)
{
scj = 0;
}
var sc2 = getCoordForCursor(max);
int sc2i = (int)((sc2.Y + TextOffset.Y) / SizePerOneSymbol.Y);
int sc2j = (int)((sc2.X + TextOffset.X) / SizePerOneSymbol.X);
if (sc2j < 0)
{
sc2j = 0;
}
if (sci == sc2i)//same line
{
renderer.Draw(GraphicsEngine.pixel, new Rectangle((int)(position.X + sc.X), (int)(position.Y + sc.Y),
(int)(sc2.X - sc.X), (int)charSize.Y), SelectionColor);
}
else//multiline
{
renderer.Draw(GraphicsEngine.pixel, new Rectangle((int)(position.X + sc.X), (int)(position.Y + sc.Y),
(int)(Font.MeasureString(DrawTextLines[sci].Substring(scj)).X - sc.X), (int)charSize.Y), SelectionColor);
float c = sc.Y + SizePerOneSymbol.Y;
for (int i = sci + 1; i < sc2i; i++)
{
renderer.Draw(GraphicsEngine.pixel, new Rectangle((int)(position.X), (int)(position.Y + c),
(int)(Font.MeasureString(DrawTextLines[i]).X), (int)charSize.Y), SelectionColor);
c += SizePerOneSymbol.Y;
}
renderer.Draw(GraphicsEngine.pixel, new Rectangle((int)(position.X), (int)(position.Y + sc2.Y),
(int)(sc2.X), (int)charSize.Y), SelectionColor);
}
}
//text
renderer.DrawString(font, DrawText, position - TextOffset, ForegroundColor,
Renderer.TextAlignment.Left);
//cursor
if (Editable && isFocused && Main.Ticks % 60 < 30)
{
renderer.Draw(GraphicsEngine.pixel, new Rectangle((int)(position.X + cursorPos.X), (int)(position.Y + cursorPos.Y),
1, (int)charSize.Y), CursorColor);
}
renderer.ResetScissorRectangle();
base.Draw(renderer);
if (ShouldOffset)
{
position = posold;
}
}
protected override void FillTab()
{
Rect rect = new Rect(0f, TopPadding, size.x, size.y - TopPadding);
Rect rect2 = rect.ContractedBy(10f);
GUI.BeginGroup(rect2);
Text.Font = GameFont.Small;
GUI.color = Color.white;
UpgradeNode additionalStatNode = null;
UpgradeNode highlightedPreMetNode = null;
Rect upgradeButtonRect = new Rect(screenWidth - BottomDisplayedOffset - 80f, BottomWindowEdge - 30f, 75f, 25f);
Rect cancelButtonRect = new Rect(LeftWindowEdge + 5f, BottomWindowEdge - 30f, 75f, 25f);
Rect displayRect = new Rect(SelPawnUpgrade.VehicleDef.drawProperties.upgradeUICoord.x, SelPawnUpgrade.VehicleDef.drawProperties.upgradeUICoord.y, SelPawnUpgrade.VehicleDef.drawProperties.upgradeUISize.x, SelPawnUpgrade.VehicleDef.drawProperties.upgradeUISize.y);
if (VehicleMod.settings.debug.debugDrawNodeGrid)
{
DrawBackgroundGrid();
}
if (Prefs.DevMode)
{
var font = Text.Font;
Text.Font = GameFont.Tiny;
Rect screenInfo = new Rect(LeftWindowEdge + 5f, GridSpacing.y + 3f, screenWidth - LeftWindowEdge - 10f, 50f);
Widgets.Label(screenInfo, $"Screen Size: ({size.x},{size.y}) \nBottomEdge: {BottomWindowEdge}px \nLeftWindowEdge: {LeftWindowEdge}px");
Text.Font = font;
}
if (selectedNode != null && !SelPawnUpgrade.CompUpgradeTree.CurrentlyUpgrading)
{
float imageWidth = TotalIconSizeScalar / selectedNode.UpgradeImage.width;
float imageHeight = TotalIconSizeScalar / selectedNode.UpgradeImage.height;
Rect selectedRect = new Rect(GridOrigin.x + (GridSpacing.x * selectedNode.GridCoordinate.x) - (imageWidth / 2), GridOrigin.y + (GridSpacing.y * selectedNode.GridCoordinate.z) - (imageHeight / 2) + (TopPadding * 2), imageWidth, imageHeight);
selectedRect = selectedRect.ExpandedBy(2f);
GUI.DrawTexture(selectedRect, BaseContent.WhiteTex);
}
if (Widgets.ButtonText(upgradeButtonRect, "Upgrade".Translate()) && selectedNode != null && !selectedNode.upgradeActive)
{
if (SelPawnUpgrade.CompUpgradeTree.Disabled(selectedNode))
{
Messages.Message("DisabledFromOtherNode".Translate(), MessageTypeDefOf.RejectInput, false);
}
else if (SelPawnUpgrade.CompUpgradeTree.PrerequisitesMet(selectedNode))
{
SoundDefOf.ExecuteTrade.PlayOneShotOnCamera(SelPawnUpgrade.Map);
SoundDefOf.Building_Complete.PlayOneShot(SelPawnUpgrade);
SelPawnUpgrade.drafter.Drafted = false;
if (DebugSettings.godMode)
{
SelPawnUpgrade.CompUpgradeTree.FinishUnlock(selectedNode);
}
else
{
SelPawnUpgrade.CompUpgradeTree.StartUnlock(selectedNode);
}
selectedNode.upgradePurchased = true;
selectedNode = null;
}
else
{
Messages.Message("MissingPrerequisiteUpgrade".Translate(), MessageTypeDefOf.RejectInput, false);
}
}
if (SelPawnUpgrade.CompUpgradeTree.CurrentlyUpgrading)
{
if (Widgets.ButtonText(cancelButtonRect, "CancelUpgrade".Translate()))
{
SelPawnUpgrade.CompUpgradeTree.CancelUpgrade();
}
}
else if (selectedNode != null && SelPawnUpgrade.CompUpgradeTree.NodeListed(selectedNode).upgradeActive&& SelPawnUpgrade.CompUpgradeTree.LastNodeUnlocked(selectedNode))
{
if (Widgets.ButtonText(cancelButtonRect, "RefundUpgrade".Translate()))
{
SelPawnUpgrade.CompUpgradeTree.RefundUnlock(SelPawnUpgrade.CompUpgradeTree.NodeListed(selectedNode));
selectedNode = null;
}
}
else
{
Widgets.ButtonText(cancelButtonRect, string.Empty);
}
foreach (UpgradeNode upgradeNode in SelPawnUpgrade.CompUpgradeTree.upgradeList)
{
if (!upgradeNode.prerequisiteNodes.NullOrEmpty())
{
foreach (UpgradeNode prerequisite in SelPawnUpgrade.CompUpgradeTree.upgradeList.FindAll(x => upgradeNode.prerequisiteNodes.Contains(x.upgradeID)))
{
Vector2 start = new Vector2(GridOrigin.x + (GridSpacing.x * prerequisite.GridCoordinate.x), GridOrigin.y + (GridSpacing.y * prerequisite.GridCoordinate.z) + (TopPadding * 2));
Vector2 end = new Vector2(GridOrigin.x + (GridSpacing.x * upgradeNode.GridCoordinate.x), GridOrigin.y + (GridSpacing.y * upgradeNode.GridCoordinate.z) + (TopPadding * 2));
Color color = Color.grey;
if (upgradeNode.upgradeActive)
{
color = Color.white;
}
else if (!string.IsNullOrEmpty(upgradeNode.disableIfUpgradeNodeEnabled))
{
try
{
UpgradeNode preUpgrade = SelPawnUpgrade.CompUpgradeTree.NodeListed(upgradeNode.disableIfUpgradeNodeEnabled);
float imageWidth = TotalIconSizeScalar / preUpgrade.UpgradeImage.width;
float imageHeight = TotalIconSizeScalar / preUpgrade.UpgradeImage.height;
Rect preUpgradeRect = new Rect(GridOrigin.x + (GridSpacing.x * preUpgrade.GridCoordinate.x) - (imageWidth / 2), GridOrigin.y + (GridSpacing.y * preUpgrade.GridCoordinate.z) - (imageHeight / 2) + (TopPadding * 2), imageWidth, imageHeight);
if (!SelPawnUpgrade.CompUpgradeTree.CurrentlyUpgrading)
{
if (preUpgrade.upgradePurchased)
{
color = Color.black;
}
else if (Mouse.IsOver(preUpgradeRect))
{
color = Color.red;
}
}
}
catch
{
Log.Error($"Unable to find UpgradeNode {upgradeNode.disableIfUpgradeNodeEnabled} on iteration. Are you referencing the proper upgradeID?");
}
}
Widgets.DrawLine(start, end, color, 2f);
}
}
}
bool preDrawingDescriptions = false;
for (int i = 0; i < SelPawnUpgrade.CompUpgradeTree.upgradeList.Count; i++)
{
UpgradeNode upgradeNode = SelPawnUpgrade.CompUpgradeTree.upgradeList[i];
float imageWidth = TotalIconSizeScalar / upgradeNode.UpgradeImage.width;
float imageHeight = TotalIconSizeScalar / upgradeNode.UpgradeImage.height;
Rect upgradeRect = new Rect(GridOrigin.x + (GridSpacing.x * upgradeNode.GridCoordinate.x) - (imageWidth / 2), GridOrigin.y + (GridSpacing.y * upgradeNode.GridCoordinate.z) - (imageHeight / 2) + (TopPadding * 2), imageWidth, imageHeight);
Widgets.DrawTextureFitted(upgradeRect, upgradeNode.UpgradeImage, 1);
if (!SelPawnUpgrade.CompUpgradeTree.PrerequisitesMet(upgradeNode))
{
Widgets.DrawBoxSolid(upgradeRect, PrerequisitesNotMetColor);
}
else if (!upgradeNode.upgradeActive || !upgradeNode.upgradePurchased)
{
Widgets.DrawBoxSolid(upgradeRect, NotUpgradedColor);
}
if (!upgradeNode.prerequisiteNodes.NotNullAndAny())
{
if (!string.IsNullOrEmpty(upgradeNode.rootNodeLabel))
{
float textWidth = Text.CalcSize(upgradeNode.rootNodeLabel).x;
Rect nodeLabelRect = new Rect(upgradeRect.x - (textWidth - upgradeRect.width) / 2, upgradeRect.y - 20f, 10f * upgradeNode.rootNodeLabel.Length, 25f);
Widgets.Label(nodeLabelRect, upgradeNode.rootNodeLabel);
}
}
Rect buttonRect = new Rect(GridOrigin.x + (GridSpacing.x * upgradeNode.GridCoordinate.x) - (imageWidth / 2), GridOrigin.y + (GridSpacing.y * upgradeNode.GridCoordinate.z) - (imageHeight / 2) + (TopPadding * 2), imageWidth, imageHeight);
Rect infoLabelRect = new Rect(5f, BottomWindowEdge, LeftWindowEdge, 150f);
GUIStyle infoLabelFont = new GUIStyle(Text.CurFontStyle);
infoLabelFont.fontStyle = FontStyle.Bold;
if (!SelPawnUpgrade.CompUpgradeTree.CurrentlyUpgrading)
{
if (Mouse.IsOver(upgradeRect))
{
preDrawingDescriptions = true;
if (!upgradeNode.upgradePurchased)
{
additionalStatNode = upgradeNode;
highlightedPreMetNode = upgradeNode;
}
UIElements.LabelStyled(infoLabelRect, upgradeNode.label, infoLabelFont);
Widgets.Label(new Rect(infoLabelRect.x, infoLabelRect.y + 20f, infoLabelRect.width, 140f), upgradeNode.informationHighlighted);
}
if ((Mouse.IsOver(upgradeRect)) && SelPawnUpgrade.CompUpgradeTree.PrerequisitesMet(upgradeNode) && !upgradeNode.upgradeActive)
{
GUI.DrawTexture(upgradeRect, TexUI.HighlightTex);
}
if (SelPawnUpgrade.CompUpgradeTree.PrerequisitesMet(upgradeNode))
{
if (Widgets.ButtonInvisible(buttonRect, true))
{
if (selectedNode != upgradeNode)
{
selectedNode = upgradeNode;
SoundDefOf.Checkbox_TurnedOn.PlayOneShotOnCamera();
}
else
{
selectedNode = null;
SoundDefOf.Checkbox_TurnedOff.PlayOneShotOnCamera();
}
}
}
}
}
Rect selectedLabelRect = new Rect(5f, BottomWindowEdge, LeftWindowEdge, 150f);
GUIStyle selectedLabelFont = new GUIStyle(Text.CurFontStyle);
selectedLabelFont.fontStyle = FontStyle.Bold;
if (selectedNode != null && !preDrawingDescriptions)
{
if (!selectedNode.upgradePurchased)
{
additionalStatNode = selectedNode;
}
UIElements.LabelStyled(selectedLabelRect, selectedNode.label, selectedLabelFont);
Widgets.Label(new Rect(selectedLabelRect.x, selectedLabelRect.y + 20f, selectedLabelRect.width, 140f), selectedNode.informationHighlighted);
}
Rect labelRect = new Rect(0f, 0f, rect2.width - 16f, 20f);
if (!VehicleMod.settings.debug.debugDrawNodeGrid)
{
Widgets.Label(labelRect, SelPawnUpgrade.Label);
}
Color lineColor = GUI.color;
GUI.color = new Color(0.3f, 0.3f, 0.3f, 1f);
Widgets.DrawLineHorizontal(0, TopViewPadding, screenWidth);
Widgets.DrawLineHorizontal(0, BottomWindowEdge, screenWidth);
Widgets.DrawLineHorizontal(0, screenHeight - SideDisplayedOffset - 1f, screenWidth);
Widgets.DrawLineVertical(0, TopViewPadding, screenHeight);
Widgets.DrawLineVertical(screenWidth - BottomDisplayedOffset - 1f, TopViewPadding, screenHeight);
if (VehicleMod.settings.main.drawUpgradeInformationScreen)
{
Widgets.DrawLineVertical(LeftWindowEdge, TopViewPadding, screenHeight);
}
GUI.color = lineColor;
if (VehicleMod.settings.main.drawUpgradeInformationScreen)
{
if (SelPawnUpgrade != null)
{
try
{
Vector2 display = SelPawnUpgrade.VehicleDef.drawProperties.upgradeUICoord;
float UISizeX = SelPawnUpgrade.VehicleDef.drawProperties.upgradeUISize.x;
float UISizeY = SelPawnUpgrade.VehicleDef.drawProperties.upgradeUISize.y;
RenderHelper.DrawVehicleTex(new Rect(display.x, display.y, UISizeX, UISizeY), VehicleTexture, SelPawnUpgrade,
SelPawnUpgrade.pattern, true, SelPawnUpgrade.DrawColor, SelPawnUpgrade.DrawColorTwo, SelPawnUpgrade.DrawColorThree);
if (VehicleMod.settings.debug.debugDrawCannonGrid)
{
Widgets.DrawLineHorizontal(displayRect.x, displayRect.y, displayRect.width);
Widgets.DrawLineHorizontal(displayRect.x, displayRect.y + displayRect.height, displayRect.width);
Widgets.DrawLineVertical(displayRect.x, displayRect.y, displayRect.height);
Widgets.DrawLineVertical(displayRect.x + displayRect.width, displayRect.y, displayRect.height);
if (screenWidth - (displayRect.x + displayRect.width) < 0)
{
Resize = new Vector2(screenWidth + displayRect.x, screenHeight);
resizeCheck = true;
}
}
if (VehicleMod.settings.debug.debugDrawNodeGrid)
{
Widgets.DrawLineHorizontal(LeftWindowEdge, 70f, screenWidth - LeftWindowEdge);
int lineCount = (int)(screenWidth - LeftWindowEdge) / 10;
for (int i = 1; i <= lineCount; i++)
{
Widgets.DrawLineVertical(LeftWindowEdge + 10 * i, 70f, (i % 5 == 0) ? 10 : 5);
}
var color = GUI.color;
GUI.color = Color.red;
Widgets.DrawLineVertical(LeftWindowEdge + (((screenWidth - BottomDisplayedOffset) - LeftWindowEdge) / 2), 70f, 12f);
GUI.color = color;
}
SelPawnUpgrade.CompUpgradeTree.upgradeList.Where(u => u.upgradePurchased && u.upgradeActive).ForEach(u => u.DrawExtraOnGUI(new Rect(display.x, display.y, UISizeX, UISizeY)));
if (selectedNode != null)
{
selectedNode.DrawExtraOnGUI(new Rect(display.x, display.y, UISizeX, UISizeY));
}
if (highlightedPreMetNode != null)
{
highlightedPreMetNode.DrawExtraOnGUI(new Rect(display.x, display.y, UISizeX, UISizeY));
}
}
catch (Exception ex)
{
Log.ErrorOnce($"Unable to display {SelPawnUpgrade.def.LabelCap} Texture on Upgrade Screen. Error: {ex.Message} \n StackTrace: {ex.StackTrace}", SelPawnUpgrade.thingIDNumber);
}
}
}
if (additionalStatNode != null)
{
DrawCostItems(additionalStatNode);
}
else if (selectedNode != null)
{
DrawCostItems(selectedNode);
}
DrawStats(additionalStatNode as StatUpgrade);
if (SelPawnUpgrade.CompUpgradeTree.CurrentlyUpgrading)
{
Rect greyedViewRect = new Rect(0, TopViewPadding, LeftWindowEdge, BottomWindowEdge - TopViewPadding);
Widgets.DrawBoxSolid(greyedViewRect, LockScreenColor);
Rect greyedLabelRect = new Rect(LeftWindowEdge / 2 - 17f, (BottomWindowEdge - TopViewPadding) / 2, 100f, 100f);
string timeFormatted = VehicleMod.settings.main.useInGameTime ? RimWorldTime.TicksToGameTime(SelPawnUpgrade.CompUpgradeTree.TimeLeftUpgrading) : RimWorldTime.TicksToRealTime(SelPawnUpgrade.CompUpgradeTree.TimeLeftUpgrading);
timeFormatted = SelPawnUpgrade.CompUpgradeTree.TimeLeftUpgrading.ToString();
Widgets.Label(greyedLabelRect, timeFormatted);
DrawCostItems(null);
}
GUI.EndGroup();
GUI.color = Color.white;
Text.Anchor = TextAnchor.UpperLeft;
}
protected override void Draw(Microsoft.Xna.Framework.GameTime gameTime, RenderHelper render)
{
render.Clear(Color.Black);
render.RenderTextureComplete(tex, Color.White, GraphicInfo.FullScreenRectangle, Matrix.Identity);
}
