public MainPage()
{
this.InitializeComponent();
_viewModel = new DemoModel();
DataContext = _viewModel;
tileLayer.LayerConfiguration.TileLoader.PropertyChanged += TileLoaderOnPropertyChanged;
}
public Task <TranStatus> AddDemo(DemoModel model)
{
using (demoRepository = new DemoRepository())
{
return(demoRepository.AddDemo(model));
}
}
public void CreateDefinition()
{
ApplicationDefinition application = DemoModel.Create();
Assert.AreEqual("Demo", application.Name);
Assert.AreEqual(application.Databases.Count, 1);
}
public void LoadDemo(DemoModel d)
{
demo = d;
TitleText.Text = demo.Title;
CanvasWrapper.LoadDemo(demo);
if (demo.Points != null && demo.Points.Count > 0)
{
foreach (var v in demo.Points)
{
EventBus.Publish(new InputPointSelected(v.Alternates.DotIndexLeft, v.Alternates.DotIndexTop,
v.X, v.Y));
CanvasWrapper.AddInputPoint(v.Alternates.DotIndexLeft, v.Alternates.DotIndexTop, v.X, v.Y);
}
}
if (demo.Polygons != null && demo.Polygons.Count > 0)
{
foreach (var poly in demo.Polygons)
{
foreach (var line in poly.Lines)
{
CanvasWrapper.AddPolygonLine(
line.StartPoint.Alternates.DotIndexLeft, line.StartPoint.Alternates.DotIndexTop,
line.EndPoint.Alternates.DotIndexLeft, line.EndPoint.Alternates.DotIndexTop,
line.StartPoint.X, line.StartPoint.Y,
line.EndPoint.X, line.EndPoint.Y
);
}
}
}
}
public async Task <IActionResult> PutDemoModel(int id, DemoModel demoModel)
{
if (id != demoModel.Id)
{
return(BadRequest());
}
_context.Entry(demoModel).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DemoModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public DemoModel HelloSendModel(DemoModel model)
{
model.T1 = model.T1 + 10;
model.T2 = model.T2 + "11";
model.T3 = model.T3.AddDays(12);
return(model);
}
internal static void FireAll(DemoModel model, ExtModel extModel)
{
model.Boolean_property.Set(false);
model.Boolean_array.Set(new[] { false, true, false });
var scalar = new MyScalar(
false,
50,
32000,
1000000000,
-2000000000000000000,
3.14f,
-123456789.012345678,
byte.MaxValue - 1,
ushort.MaxValue - 1,
uint.MaxValue - 1,
ulong.MaxValue - 1,
MyEnum.net,
Flags.anyFlag | Flags.netFlag,
MyInitializedEnum.hundred
);
// ReSharper disable once UnusedVariable
// ReSharper disable once InconsistentNaming
var(_bool, _byte, _short, _int, _long, _float, _double, _unsigned_byte, unsigned_short, _unsigned_int, _unsigned_long, _my_enum, _flags, initializedEnum) = scalar;
var(first, second) = new ComplicatedPair(new Derived("First"), new Derived("Second"));
model.Scalar.Set(scalar);
model.Set.Add(50);
model.MapLongToString.Add(50, "C#");
const string valA = "C#";
const string valB = "protocol";
model.Interned_string.Set(valA);
model.Interned_string.Set(valA);
model.Interned_string.Set(valB);
model.Interned_string.Set(valB);
model.Interned_string.Set(valA);
var derived = new Derived("C# instance");
model.Polymorphic.Set(derived);
var openDerived = new OpenDerived("C# instance open derived string", "C# instance open string");
model.Polymorphic_open.Set(openDerived);
var openClass = new OpenClass("c# test");
openClass.String.Set("property");
model.Enum.Value = MyEnum.net;
extModel.Checker.Fire();
model.Struct_with_open_field.Value = new StructWithOpenStructField(new OpenStructInField("", "", 456, "", ""));
}
public string AddDemoModel(DemoModel demoModel)
{
DemoModelDao.Instance.Add(demoModel);
var count = DemoModelDao.Instance.SaveChanges();
return(count > 0 ? "success" : "save error");
}
public async Task <ActionResult> AddDemoModel()
{
var models = new List <DemoModel>();
for (int i = 0; i < 100; i++)
{
var testModel = new DemoModel()
{
CustomerName = i + "-Levy" + DateTime.Now.ToString("HH:mm:ss"),
IdentityCardType = 1
};
models.Add(testModel);
}
for (int i = 0; i < 100; i++)
{
var testModel = new DemoModel()
{
CustomerName = i + "-zzzz" + DateTime.Now.ToString("HH:mm:ss"),
IdentityCardType = 2
};
models.Add(testModel);
}
var res = await Task.FromResult(DemoModelBiz.Instance.AddDemoModel(models));
return(Succeed(res));
}
public async Task <DemoModel> PostModel([FromBody] DemoModel model)
{
_context.DemoModels.Add(model);
await _context.SaveChangesAsync();
return(model);
}
private void GlControl_Load(object sender, EventArgs eArgs)
{
try
{
demo = DemoModelFactory.DemoModelFactory.Create(this);
//make for valid time source even if no new demo is loaded afterwards (when starting with shader cmd line argument)
Demo_OnTimeSourceLoaded(null, EventArgs.Empty);
demo.SetCustomUniforms += Demo_OnSetCustomUniforms;
demo.TimeSource.Loaded += Demo_OnTimeSourceLoaded;
demo.Uniforms.UniformAdded += Uniforms_OnAdd;
demo.Uniforms.UniformRemoved += Uniforms_OnRemove;
demo.Uniforms.UniformAdded += multiGraph.Uniforms_OnAdd;
demo.Uniforms.UniformRemoved += multiGraph.Uniforms_OnRemove;
demo.Uniforms.ChangedKeyframes += multiGraph.Uniforms_OnChange;
demo.Uniforms.ChangedKeyframes += (s, a) => camera.UpdateFromUniforms(demo.Uniforms, demo.TimeSource.Position);
demo.Uniforms.ChangedKeyframes += (s, a) => glControl.Invalidate();
demo.Shaders.Changed += Shaders_OnChange;
demo.ShaderKeyframes.Changed += ShaderKeframes_OnChange;
demo.Textures.Changed += Textures_OnChange;
}
catch (Exception e)
{
log.Append(e.Message);
}
}
public ActionResult Convert(DemoModel model)
{
PedamorfResponse response = null;
try
{
using (PedamorfServiceClient client = PedamorfServiceManager.GetClient(model.ServiceHost))
{
if (!string.IsNullOrEmpty(model.UrlButton))
{
response = client.ConvertUrl(model.Url,
new HtmlConversionOptions()
{
Orientation = model.Landscape ? PageOrientation.Landscape : PageOrientation.Portrait
});
}
else if (!string.IsNullOrEmpty(model.HtmlButton))
{
response = client.ConvertHtml(model.Html);
}
else if (!string.IsNullOrEmpty(model.DocumentButton) && model.Document1.ContentLength > 0)
{
response = client.ConvertFiles(model.Document1.InputStream, model.Document1.FileName, model.Document2.InputStream, model.Document2.FileName);
}
else if (!string.IsNullOrEmpty(model.ImageButton) && model.Image.ContentLength > 0)
{
ImageConversionOptions options = new ImageConversionOptions();
int imageWidth;
int imageHeight;
if (int.TryParse(model.ImageWidth, out imageWidth))
{
options.ImageWidthPixelsMin = imageWidth;
}
if (int.TryParse(model.ImageHeight, out imageHeight))
{
options.ImageHeightPixelsMin = imageHeight;
}
response = client.ConvertImage(model.Image.InputStream, model.Image.FileName, options);
}
}
}
catch (Exception ex)
{
TempData["error"] = ex.Message;
return(View());
}
if (!response.Error)
{
return(File(response.ResultPdf, "application/pdf"));
}
else
{
TempData["error"] = response.ErrorMessage;
return(View());
}
}
public JsonResult GetDetail(int id)
{
DemoModel model = new DemoModel();
model.AnswersIds = new List <int>();
model.Answers = new List <string>();
model.ValueAnswer = new List <string>();
model.IsCheckDelete = new List <string>();
model.TechnologyList = new List <string>();
// select data by id here display static data;
var allAnswerByIdQuestion = _answerDal.GetAnswersByQuestionID(id);
foreach (var answer in allAnswerByIdQuestion)
{
model.Answers.Add(answer.Text_Answer);
model.AnswersIds.Add(answer.Id);
if (answer.Value == true)
{
model.ValueAnswer.Add("True");
}
else
{
model.ValueAnswer.Add("False");
}
}
model.Category = _technologyDal.GetTechnologyQuestionById(Convert.ToInt32(_questionDal.GetQuestionById(id).QuestionTechnologyID)).TechnologyQuestionText;
model.Type = _questionDal.GetQuestionTypeById(id);
model.Level = _questionDal.GetQuestionById(id).LevelQuestion;
model.TechnologyList = _technologyDal.GetAllTechnologyQuestions().Select(r => r.TechnologyQuestionText).ToList();
return(Json(model));
}
// POST (create item)
public async Task <IHttpActionResult> Post([FromBody] DemoModel model)
{
_logger.Info($"adding model with name {model.Name}");
try
{
await _demoModelService.CreateDemoModelAsync(model);
return(Ok(model));
}
catch (DemoServiceException ex)
{
if (ex.Error == DemoServiceException.ErrorType.WrongName)
{
_logger.Info($"Wrong model name {model.Name} detected");
return(this.BadRequest("Wrong name"));
}
throw ex;
}
catch (Exception ex)
{
_logger.Error(ex, $"Server error occured while trying to add item with name {model.Name}");
return(this.InternalServerError());
}
}
public DemoPresenter(DemoModel model, Demoview view)
{
this.model = model;
this.view = view;
view.Presenter = this;
}
public ActionResult Demo(InputDataModel InputData)
{
DemoModel result = new DemoModel(InputData);
ViewBag.Vud = result.Vud;
ViewBag.Wud = result.Wud;
ViewBag.Ph = result.Ph;
ViewBag.Ro_h = result.Ro_h;
ViewBag.Lambda = result.Lambda;
ViewBag.W_g = result.W_g;
ViewBag.Ro_g = result.Ro_g;
ViewBag.H0 = result.H0;
ViewBag.D = result.D;
ViewBag.Vm = result.Vm;
ViewBag.d_dn = result.d_dn;
ViewBag.d_g = result.d_g;
ViewBag.V = result.V;
ViewBag.H_k = result.H_k;
ViewBag.H_c = result.H_c;
ViewBag.H_v = result.H_v;
ViewBag.t_c = result.t_c;
ViewBag.t_dn = result.t_dn;
ViewBag.t_k = result.t_k;
ViewBag.delta = result.delta;
ViewBag.D_n = result.D_n;
ViewBag.H = result.H;
ViewBag.d_otv = result.d_otv;
// ! Save input data to Session
Session["InputData"] = InputData;
return(View("RezultDemo"));
}
private void CreateButton_Click(object sender, RoutedEventArgs e)
{
var demo = new DemoModel();
var cbi = AlgoCombo.SelectedItem as ComboBoxItem;
demo.AlgorithmId = Int32.Parse(cbi.Name.Substring(4));
demo.AlgorithmIndex = AlgoCombo.SelectedIndex;
demo.Title = FullName.Text;
demo.ShortTitle = ShortName.Text;
double xmin = Double.Parse(xMinText.Text);
double xmax = Double.Parse(xMaxText.Text);
double ymin = Double.Parse(yMinText.Text);
double ymax = Double.Parse(yMaxText.Text);
double xstart = Double.Parse(xStartText.Text);
double ystart = Double.Parse(yStartText.Text);
int xCount = Int32.Parse(xCountText.Text);
int yCount = Int32.Parse(yCountText.Text);
demo.AxisConfig = new AxisModel {
XMin = xmin, XMax = xmax, YMin = ymin, YMax = ymax,
XStart = xstart, YStart = ystart, XCount = xCount, YCount = yCount
};
EventBus.Publish <DemoCreated>(new DemoCreated {
Demo = demo
});
Close();
}
public override void Start(string[] args)
{
Before(args);
Queue(() =>
{
var demoModel = new DemoModel(ModelLifetime, Protocol);
var entity = demoModel.Property_with_default;
int count = 0;
entity.Advise(ModelLifetime, it =>
{
if (!entity.IsLocalChange() && entity.Value != DemoModel.const_for_default)
{
Printer.PrintIfRemoteChange(entity, "property_with_default", it);
if (++count == 2)
{
Finished = true;
}
}
});
entity.Set(new string('5', 100_000));
entity.Set(new string('0', 100_000));
});
After();
}
public async Task <IActionResult> Save(DemoModel model)
{
var controller = typeof(DemoController).Name;
_logger.LogInformation($"Save method on {controller} started");
if (model == null)
{
_logger.LogWarning($"Save method on {controller} did not find any value in the request");
return(NoContent());
}
await _demoService.Save(new DemoEntity
{
Id = model.Id,
Description = model.Description,
Text = model.Text,
Date = DateTime.UtcNow
});
_logger.LogInformation($"Save method on {controller} finished successfully");
return(Ok());
}
public IActionResult GetData(string name)
{
try
{
//获取配置脚本的内容
ViewData["Before"] = GetOrSetScript(SCRIPT_FILE_NAME_Before);
ViewData["After"] = GetOrSetScript(SCRIPT_FILE_NAME_After);
//测试数据
var data = DemoModel.GetDemoDatas();
//执行before脚本，控制传入的字段
var ss = ExecuteBeforeScript(name);
//利用before脚本中返回的值过滤Name字段（模拟利用before脚本控制搜索条件）
if (!string.IsNullOrEmpty(ss))
{
data = data.Where(t => t.Name.Contains(ss)).ToList();
}
//执行After脚本（模拟利用After脚本控制返回结果）
var result = ExecuteAfterScript(data);
ViewData["AfterData"] = result;
ViewData["ErrorData"] = "查询成功！";
}
catch (Exception ex)
{
ViewData["ErrorData"] = ex.ToString();
}
return(View());
}
//
// GET: /Benchmark/
public ActionResult Index()
{
var message = "\nReduced images sizes:\n\n";
var lastByteSize = 0L;
var demoModel = new DemoModel();
var imageGenerator = new ImageGenerator();
var bitmap = imageGenerator.GenerateDemoImage(Server.MapPath("~/Images/"), demoModel.IconName, demoModel.ForecastText);
//un-reduced size
using (var ms = new MemoryStream())
{
bitmap.Save(ms, ImageFormat.Png);
message += string.Format("Unreduced size was {0} bytes.\n\n", ms.Length);
}
//calculate the size of each reducers output png image
foreach (var reducer in demoModel.PngColorReducers)
{
IPngColorReducer colorReducer = PngColorReducerFactory.GetReducer(reducer);
var pngStream = colorReducer.ReduceColorDepth(bitmap);
lastByteSize = pngStream.Length;
message += string.Format("{0} size was {1} bytes.\n\n", reducer, lastByteSize);
}
bitmap.Dispose();
ViewData["Message"] = message;
return(View());
}
public ActionResult Details(object id)
{
ViewData[EditFlag] = true;
var item = DemoModel.SingleOrDefault(id);
return(View(item));
}
public async Task <ActionResult <DemoModel> > PostDemoModel(DemoModel demoModel)
{
_context.ModelItem.Add(demoModel);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetDemoModel", new { id = demoModel.Id }, demoModel));
}
public override async Task AfterValidation(AddDemoCommand request)
{
var registered = await _demoRepository
.ExistsByExpressionAsync(x => x.Description == request.Description);
if (registered)
{
NotifyError("O registro já existe");
return;
}
var newRecord = new DemoModel
{
Id = Guid.NewGuid(),
Description = request.Description
};
await _demoRepository.InsertOrUpdateAsync(newRecord);
if (!HasNotification() && _unitOfWork.CommitAsync().Result)
{
await _mediator.RaiseEvent(new AddedDemoEvent(newRecord));
}
else
{
NotifyError("Commit", "Tivemos um problema ao tentar salvar seus dados.");
}
}
public ActionResult Index()
{
//Session
Session["check"] = "test";
System.Web.HttpContext.Current.Session["check2"] = "test2";
var data = (string)System.Web.HttpContext.Current.Session["check2"];
HttpSessionStateBase datas = new HttpSessionStateWrapper(System.Web.HttpContext.Current.Session);
datas.Add("check3", "test3");
//Hiddenfield
var model = new DemoModel {
Property1 = 10,
Property2 = 20
};
//Cookies
//ViewData
ViewData.Add(new KeyValuePair <string, object>("", "10"));
//ViewBag
//TempData
//TempData.Add("Count",10);
return(View(model));
}
public DemoModelDto CreateOrEditDemoModel(DemoModelInput demoModelInput)
{
DemoModel demoModelEntity = null;
if (demoModelInput.Id == 0)
{
// Insert
demoModelEntity = ObjectMapper.Map <DemoModel>(demoModelInput);
SetAuditInsert(demoModelEntity);
demoModelRepository.Insert(demoModelEntity);
CurrentUnitOfWork.SaveChanges();
}
else
{
// Update
demoModelEntity = demoModelRepository.GetAll().Where(x => x.IsDelete == false).SingleOrDefault(x => x.Id == demoModelInput.Id);
if (demoModelEntity == null)
{
return(null);
}
ObjectMapper.Map(demoModelInput, demoModelEntity);
SetAuditEdit(demoModelEntity);
demoModelRepository.Update(demoModelEntity);
CurrentUnitOfWork.SaveChanges();
}
return(ObjectMapper.Map <DemoModelDto>(demoModelEntity));
}
public static string Insert(DemoModel _demoModel)
{
DbCommand command = Catalog_Access.CreateCommand();
//Have to wite the stored procedure
command.CommandText = "sp_insert_Demo";
DbParameter param;
param = command.CreateParameter();
param.ParameterName = "@Name";
param.Value = _demoModel.Name;
param.DbType = DbType.String;
command.Parameters.Add(param);
param = command.CreateParameter();
param.ParameterName = "@CreatedBy";
param.Value = _demoModel.CreatedBy;
param.DbType = DbType.String;
command.Parameters.Add(param);
param = command.CreateParameter();
param.ParameterName = "@Return";
param.DbType = DbType.String;
param.Size = 2;
param.Direction = ParameterDirection.Output;
command.Parameters.Add(param);
Catalog_Access.ExecuteNonQuery(command);
string Return = command.Parameters["@Return"].Value.ToString();
return(Return);
}
// Demonstrate the mapping of JObject to a POCO or DTO
private async Task <bool> JObjectMappingDemo()
{
// Returns a JObject from the root object 'demo'
var data = await _demoApiClient.GetData("Demo/Get200/1", "demo");
// Map using Newtonsoft.Json's JsonSerializer via the PopulateObject extension method
// This works if the property names match, differences in case don't matter
// Refer to Extensions/JsonExtensions.cs
DemoModel demoModel = new DemoModel();
data.PopulateObject <DemoModel>(demoModel);
// Note: For mapping non matching property names we could use a Custom JsonConverter
// If you like Automapper
// Map using Automapper (actually uses JsonSerializer in the config)
// Must use an existing object for this mapping config
// Refer to MappingProfile.cs for the Mapping config
DemoModel demoModel2 = new DemoModel();
_mapper.Map(data, demoModel2);
// Use Automapper to Map to an object where the property names don't match
// Refer to MappingProfile.cs for the Mapping config
// Because we are using a specific mapping for ExampleModel we can let automapper create the object
// For the reason why, refer to the MappingProfile.cs
ExampleModel exampleModel = _mapper.Map <ExampleModel>(data);
return(true);
}
public IActionResult Index()
{
List <DemoModel> demoList = new List <DemoModel>();
string connectionString = Configuration.GetConnectionString("con");
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
string sql = "SELECT * from [Demo].[dbo].[Users]";
SqlCommand command = new SqlCommand(sql, connection);
using (SqlDataReader dataReader = command.ExecuteReader())
{
while (dataReader.Read())
{
DemoModel demo = new DemoModel();
demo.id = Convert.ToInt32(dataReader["id"]);
demo.Name = Convert.ToString(dataReader["Name"]);
demoList.Add(demo);
}
}
connection.Close();
ViewBag.id = demoList[0].id;
ViewBag.Name = demoList[0].Name;
}
return(View());
}
static void Invoke(IDemo demo, UserInfo userInfo, DemoModel data)
{
try
{
userInfo.UserName += "_c";
demo.Create(data, userInfo);
}
catch (ActionForbiddenException e)
{
Console.WriteLine($"创建执行失败：{(e.InnerException ?? e).Message}");
}
try
{
userInfo.UserName += "_e";
data.Message = "修改调用验证";
demo.Modified(data, userInfo);
}
catch (ActionForbiddenException e)
{
Console.WriteLine($"修改执行失败：{(e.InnerException ?? e).Message}");
}
try
{
userInfo.UserName += "_d";
demo.Delete(data.PrimaryKey, userInfo);
}
catch (ActionForbiddenException e)
{
Console.WriteLine($"删除执行失败：{(e.InnerException ?? e).Message}");
}
}
/// 使用するデータのセット
public void Start( DemoModel.BasicModel useModel, DemoModel.TexContainer useTexCnr, DemoModel.ShaderContainer useShaderCnr )
{
this.useModel = useModel;
this.useTexCnr = useTexCnr;
this.useShaderCnr = useShaderCnr;
this.useModel.BindTextures( this.useTexCnr );
}
/// <summary>
/// Persists a new demo in the data store.
/// </summary>
/// <param name="demo">The <see cref="DemoModel"/> instance to persist</param>
public void Persist(DemoModel demo)
{
collection.Insert(demo);
}
protected void InitWithDefaultFBO(int defaultFBOName)
{
Console.WriteLine(string.Format("{0} {1}", GL.GetString(StringName.Renderer), GL.GetString(StringName.Version)));
////////////////////////////////////////////////////
// Build all of our and setup initial state here //
// Don't wait until our real time run loop begins //
////////////////////////////////////////////////////
m_defaultFBOName = defaultFBOName;
m_viewWidth = 100;
m_viewHeight = 100;
m_characterAngle = 0;
#if USE_VERTEX_BUFFER_OBJECTS
m_useVBOs = true;
#else
m_useVBOs = false;
#endif
var filePathName = string.Empty;
//////////////////////////////
// Load our character model //
//////////////////////////////
filePathName = NSBundle.MainBundle.PathForResource("GLData/demon", "model");
m_characterModel = DemoModel.LoadModel(filePathName);
// Build Vertex uffer Objects (VBOs) and Vertex Array Objects (VAOs) with our model data
m_characterVAOName = BuildVAO(m_characterModel);
// Cache the number of element and primtType to use later in our GL.DrawElements calls
m_characterNumElements = m_characterModel.NumElements;
m_characterPrimType = m_characterModel.PrimType;
m_characterElementType = m_characterModel.ElementType;
if(m_useVBOs)
{
//If we're using VBOs we can destroy all this memory since buffers are
// loaded into GL and we've saved anything else we need
m_characterModel = null;
}
////////////////////////////////////
// Load texture for our character //
////////////////////////////////////
filePathName = NSBundle.MainBundle.PathForResource("GLData/demon", "png");
var image = DemoImage.LoadImage(filePathName, false);
// Build a texture object with our image data
m_characterTexName = BuildTexture(image);
////////////////////////////////////////////////////
// Load and Setup shaders for character rendering //
////////////////////////////////////////////////////
DemoSource vtxSource = null;
DemoSource frgSource = null;
filePathName = NSBundle.MainBundle.PathForResource("Shaders/character", "vsh");
vtxSource = DemoSource.LoadSource(filePathName);
filePathName = NSBundle.MainBundle.PathForResource("Shaders/character", "fsh");
frgSource = DemoSource.LoadSource(filePathName);
// Build program
m_characterPrgName = BuildProgramWithVertexSource(vtxSource, frgSource, false, true);
m_characterMvpUniformIdx = GL.GetUniformLocation(m_characterPrgName, "modelViewProjectionMatrix");
if(m_characterMvpUniformIdx < 0)
Console.WriteLine("No modelViewProjectionMatrix in character shader");
#if RENDER_REFLECTION
m_reflectWidth = 512;
m_reflectHeight = 512;
////////////////////////////////////////////////
// Load a model for a quad for the reflection //
////////////////////////////////////////////////
m_quadModel = DemoModel.LoadQuadModel();
// build Vertex Buffer Objects (VBOs) and Vertex Array Object (VAOs) with our model data
m_reflectVAOName = BuildVAO(m_quadModel);
// Cache the number of element and prim type to use later in our GL.DrawElements calls
m_quadNumElements = m_quadModel.NumElements;
m_quadPrimType = m_quadModel.PrimType;
m_quadElementType = m_quadModel.ElementType;
if(m_useVBOs)
{
// Release quad Model;
m_quadModel = null;
}
/////////////////////////////////////////////////////
// Create texture and FBO for reflection rendering //
/////////////////////////////////////////////////////
m_reflectFBOName = BuildFBOWithWidth(m_reflectWidth, m_reflectHeight);
// Get the texture we created in buildReflectFBO by binding the
// reflection FBO and getting the buffer attached to color 0
GL.BindFramebuffer(FramebufferTarget.Framebuffer, m_reflectFBOName);
int iReflectTexName = 0;
GL.GetFramebufferAttachmentParameter(FramebufferTarget.Framebuffer, FramebufferSlot.ColorAttachment0, FramebufferParameterName.FramebufferAttachmentObjectName, out iReflectTexName);
m_reflectTexName = iReflectTexName;
/////////////////////////////////////////////////////
// Load and setup shaders for reflection rendering //
/////////////////////////////////////////////////////
filePathName = NSBundle.MainBundle.PathForResource("Shaders/reflect", "vsh");
vtxSource = DemoSource.LoadSource(filePathName);
filePathName = NSBundle.MainBundle.PathForResource("Shaders/reflect", "fsh");
frgSource = DemoSource.LoadSource (filePathName);
// Build Program
m_reflectPrgName = BuildProgramWithVertexSource(vtxSource, frgSource, true, false);
m_reflectModelViewUniformIdx = GL.GetUniformLocation(m_reflectPrgName, "modelViewMatrix");
if(m_reflectModelViewUniformIdx < 0)
Console.WriteLine("No modelViewMatrix in reflection shader");
m_reflectProjectionuniformIdx = GL.GetUniformLocation(m_reflectPrgName, "modelViewProjectionMatrix");
if(m_reflectProjectionuniformIdx < 0)
Console.WriteLine("No modelViewProjectionMatrix in reflection shader");
m_reflectNormalMatrixUniformIdx = GL.GetUniformLocation(m_reflectPrgName, "normalMatrix");
if(m_reflectNormalMatrixUniformIdx <0)
Console.WriteLine("No normalMatrix in reflection shader");
#endif // RENDER_REFLECTION
////////////////////////////////////////////////
// Set up OpenGL state that will never change //
////////////////////////////////////////////////
// Depth test will always be enabled
GL.Enable(EnableCap.DepthTest);
// We will always cull back faces for better performance
GL.Enable(EnableCap.CullFace);
// Always use this clear color
GL.ClearColor(.5f, .4f, .5f, 1.0f);
// Draw our scene once without presenting the rendered image.
// This is done in order to pre-warm OpenGL
// We don't need to present the buffer since we don't actually want the
// user to see this, we're only drawing as a pre-warm stage
Render();
// Reset the m_characterAngle which is incremented in render
m_characterAngle = 0;
// Check for errors to make sure all of our setup went ok
GetGLError();
}
unsafe int BuildVAO(DemoModel model)
{
int vaoName = 0;
// Create a vertex array object (VAO) to cache model parameters
GL.Oes.GenVertexArrays(1, out vaoName);
GL.Oes.BindVertexArray(vaoName);
if(m_useVBOs)
{
int posBufferName = 0;
// Creat a vertex buffer object (VBO) to store positions
GL.GenBuffers(1, out posBufferName);
// Allocate and load position data into the VBO
//int size = (int) model.PositionArraySize;
//fixed (void *ptr = &size) {
// GL.BufferData(BufferTarget.ArrayBuffer, new IntPtr (ptr), model.Positions, BufferUsage.StaticDraw);
//}
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)model.PositionArraySize, model.Positions, BufferUsage.StaticDraw);
// Enable the position attribute for this VAO
GL.EnableVertexAttribArray(POS_ATTRIB_IDX);
// Get the size of the position type so we can set the stride properly
var posTypeSize = GetGLTypeSize(model.PositionType);
// Setup parameters for position attribute in the VAO including,
// size, type, stride, and offset in the currently bound VAO
// This also attaches the position VBO to the VAO
GL.VertexAttribPointer(POS_ATTRIB_IDX, // What attribute index will this array feed in the vertex shader (see BuildProgram)
model.PositionSize, // How many element are there per position?
model.PositionType, // What is the type of this data?
false, // Do we want to normalize this data (0-1 range for fixed-point types)
model.PositionSize * posTypeSize, // What is the stride (i.e. bytes between position)?
new int[0]);
if(model.Normals != null)
{
int normalBufferName = 0;
// Create a vertex buffer object (VBO) to store positions
GL.GenBuffers(1, out normalBufferName);
GL.BindBuffer(BufferTarget.ArrayBuffer, normalBufferName);
// Allocate and load normal data into the VBO
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)model.NormalArraySize, model.Normals, BufferUsage.StaticDraw);
// Enable the normal attribute for this VAO
GL.EnableVertexAttribArray(NORMAL_ATTRIB_IDX);
// Get the size of the normal type so we can set the stride properly
var normalTypeSize = GetGLTypeSize(model.NormalType);
// Set up parameters for position attribute in the VAO including,
// size, type, stride, and offset in the currently bound VAO
// This also attaches the position VBO to the VAO
GL.VertexAttribPointer(NORMAL_ATTRIB_IDX, // What attribue index will this array feed in the vertex shader
model.NormalSize, // How many elements are there per normal?
model.NormalType, // What is the type of this data?
false, // Do we want to normalize this data (0-1 range for fixed-point types)
model.NormalSize * normalTypeSize, // What is the stride.
new int[0]);
}
if(model.TexCoords != null)
{
int texcoordBufferName = 0;
// Create a VBO to store texcoords
GL.GenBuffers(1, out texcoordBufferName);
GL.BindBuffer(BufferTarget.ArrayBuffer, texcoordBufferName);
// Allocate and load texcoord data into the VBO
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)model.TexCoordArraySize, model.TexCoords, BufferUsage.StaticDraw);
// Enable the texcoord attribute for this VAO
GL.EnableVertexAttribArray(TEXCOORD_ATTRIB_IDX);
// Get the size of the texcoord type so we can set the stride properly
var texcoordTypeSize = GetGLTypeSize(model.TexCoordType);
// Set up parameters for texcoord attribute in the VAO including,
// size, type, stride, and oofset in the currently bound VAO
// This also attaches the texcoord VBO to VAO
GL.VertexAttribPointer(TEXCOORD_ATTRIB_IDX, // What attribute index will this array feed in the vertex shader
model.TexCoordsSize, // How many elements are there per texture coord?
model.TexCoordType, // What is the type of this data in the array?
true, // Do we want to normalize this data
model.TexCoordsSize * texcoordTypeSize, // What is the stride
new int[0]);
}
int elementBufferName = 0;
// Create a VBO to vertex array elements
// This also attaches the element array buffer to the VAO
GL.GenBuffers(1, out elementBufferName);
GL.BindBuffer(BufferTarget.ArrayBuffer, elementBufferName);
// Allocate and load vertex array element data into VBO
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)model.ElementArraySize, model.Elements, BufferUsage.StaticDraw);
}
else{
// Enable the position attribute for this VAO
GL.EnableVertexAttribArray(POS_ATTRIB_IDX);
// Get the size of the position type so we can set the stride propertly
var posTypeSize = GetGLTypeSize(model.PositionType);
// Set up parameters for position attribute in the VAO including,
// size, type, stride, and offset in the currently bound VAO
// This also attaches the position VBO to the VAO
GL.VertexAttribPointer(POS_ATTRIB_IDX, // What attibute index will this array feed in the vertex shader? (also see buildProgram)
model.PositionSize, // How many elements are there per position?
model.PositionType, // What is the type of this data
false, // Do we want to normalize this data (0-1 range for fixed-pont types)
model.PositionSize*posTypeSize, // What is the stride (i.e. bytes between positions)?
model.Positions); // Where is the position data in memory?
if(model.Normals != null)
{
// Enable the normal attribute for this VAO
GL.EnableVertexAttribArray(NORMAL_ATTRIB_IDX);
// Get the size of the normal type so we can set the stride properly
var normalTypeSize = GetGLTypeSize(model.NormalType);
// Set up parmeters for position attribute in the VAO including,
// size, type, stride, and offset in the currenly bound VAO
// This also attaches the position VBO to the VAO
GL.VertexAttribPointer(NORMAL_ATTRIB_IDX, // What attibute index will this array feed in the vertex shader (see buildProgram)
model.NormalSize, // How many elements are there per normal?
model.NormalType, // What is the type of this data?
false, // Do we want to normalize this data (0-1 range for fixed-pont types)
model.NormalSize * normalTypeSize, // What is the stride (i.e. bytes between normals)?
model.Normals); // Where is normal data in memory?
}
if(model.TexCoords != null)
{
// Enable the texcoord attribute for this VAO
GL.EnableVertexAttribArray(TEXCOORD_ATTRIB_IDX);
// Get the size of the texcoord type so we can set the stride properly
var texcoordTypeSize = GetGLTypeSize(model.TexCoordType);
// Set up parmeters for texcoord attribute in the VAO including,
// size, type, stride, and offset in the currenly bound VAO
// This also attaches the texcoord array in memory to the VAO
GL.VertexAttribPointer(TEXCOORD_ATTRIB_IDX, // What attibute index will this array feed in the vertex shader (see buildProgram)
model.TexCoordsSize, // How many elements are there per texture coord?
model.TexCoordType, // What is the type of this data in the array?
false, // Do we want to normalize this data (0-1 range for fixed-point types)
model.TexCoordsSize * texcoordTypeSize, // What is the stride (i.e. bytes between texcoords)?
model.TexCoords); // Where is the texcood data in memory?
}
}
GetGLError();
return vaoName;
}
