void Mesh::DrawGeometry()
{
auto device = Device::GetInstance();
auto meshShader = ShaderStock::GetInstance()->GetMeshShader();
if (this->vertices.size() > 0 && this->triangles.size() > 0)
{
//TODO : add support for more vertex and material formats
if (this->changed)
{
std::vector<VertexFormatItem> vfitems;
vfitems.push_back(VertexFormatItem(0, DataType::FLOAT3, "POSITION", 0, 0));
vfitems.push_back(VertexFormatItem(sizeof(float) * 3, DataType::FLOAT3, "NORMAL", 0, 0));
vfitems.push_back(VertexFormatItem(sizeof(float) * 6, DataType::FLOAT2, "TEXCOORD", 0, 0));
this->vertexFormat = device->CreateVertexFormat(vfitems, meshShader, "Mesh", 0);
std::vector<MeshVertex> data(this->vertices.size());
for (size_t i = 0; i < this->vertices.size(); i++)
{
data[i].x = this->vertices[i].x;
data[i].y = this->vertices[i].y;
data[i].z = this->vertices[i].z;
data[i].nx = this->normals[i].x;
data[i].ny = this->normals[i].y;
data[i].nz = this->normals[i].z;
data[i].u = this->uv[0][i].x;
data[i].v = this->uv[0][i].y;
}
if (this->isDynamic == false)
{
this->vertexBuffer = device->CreateStaticVertexBuffer(sizeof(MeshVertex) * data.size(), &data[0]).Get();
this->indexBuffer = device->CreateStaticIndexBuffer(sizeof(uint32_t) * triangles.size(), &triangles[0]).Get();
}
this->changed = false;
}
device->SetVertexFormat(this->vertexFormat);
device->SetVertexBuffer(this->vertexBuffer, sizeof(MeshVertex), 0);
device->SetIndexBuffer(this->indexBuffer);
if (this->material.texture)
{
meshShader->SetTexture("g_texture", this->material.texture);
meshShader->SetBoolean("g_hasTexture", true);
}
else
{
meshShader->SetBoolean("g_hasTexture", false);
}
meshShader->SetValue("g_material", &this->material, sizeof(Material) - sizeof(Texture*));
meshShader->CommitChanges();
device->DrawIndexed(PrimitiveType::TRIANGLE_LIST, this->triangles.size(), 0, 0);
}
for (size_t i = 0; i < this->subMeshes.size(); i++)
this->subMeshes[i]->DrawGeometry();
}
void AnimaMappedValues::CopyBooleans(const AnimaMappedValues& src)
{
_booleansMap.clear();
const boost::unordered_map<AnimaString, bool, AnimaStringHasher>* srcBooleansMap = &src._booleansMap;
for (auto pair : *srcBooleansMap)
{
AnimaString propertyName = ExtractName(pair.first);
SetBoolean(propertyName, pair.second);
}
}
void gui_toogle_set_active(enum GUI_TOGGLE id, gboolean active)
{
if(gui_toggle_state[id] == active)
return;
gui_toggle_state[id] = active;
SetBoolean("Toggles",gui_toggle_info[id].name,gui_toggle_state[id]);
if(id == GUI_TOGGLE_BOLD)
action_redraw(0);
}
static int SetWindowAttrib(lua_State *L)
{
win_t *win = checkwindow(L, 1);
int attrib = checktarget(L, 2);
switch(attrib)
{
case GLFW_RESIZABLE:
case GLFW_DECORATED:
case GLFW_FLOATING:
case GLFW_AUTO_ICONIFY:
case GLFW_FOCUS_ON_SHOW:
return SetBoolean(L, win->window, attrib);
default:
return luaL_error(L, "invalid attribute '%s'", lua_tostring(L, 2));
}
return 0;
}
bool Config::GetBoolean(string Section, string Setting, bool Default) {
#ifdef CONFIG_FILE_ACCESS
string buffer = get_value(Section.c_str(), Setting.c_str());
if (buffer != "") {
if (buffer == "wahr" || buffer == "Wahr" || buffer == "WAHR" || buffer == "true" || buffer == "True" || buffer == "TRUE") {
return true;
} else {
return false;
}
} else {
#ifdef WRITE_DEFAULTS_ON_ACCESS
SetBoolean(Section, Setting, Default);
#endif
return Default;
}
#else
return Default;
#endif
}
static int ListboxSelectItem (lua_State * L)
{
return SetBoolean(L, Listbox_SelectItem);
}
static int CheckboxAllowClick (lua_State * L)
{
return SetBoolean(L, Checkbox_AllowClick);
}
static int CheckboxCheck (lua_State * L)
{
return SetBoolean(L, Checkbox_Check);
}
static int ButtonAllowPush (lua_State * L)
{
return SetBoolean(L, Button_AllowPush);
}
LJValue& LJValue::operator=( const LJBool& b )
{
SetBoolean(b);
return *this;
}
static int SliderAllowSnap (lua_State * L)
{
return SetBoolean(L, Slider_AllowSnap);
}
static int PaneAllowDrag (lua_State * L)
{
return SetBoolean(L, Pane_AllowDrag);
}
void AnimaRenderer::SetBoolean(const char* propertyName, bool value)
{
AnimaString str(propertyName, _allocator);
SetBoolean(str, value);
}
bool AnimaMappedValues::ReadObject(const ptree& objectTree, AnimaScene* scene, bool readName)
{
try
{
if(readName)
SetName(objectTree.get<AnimaString>("AnimaMappedValues.Name"));
for (auto& property : objectTree.get_child("AnimaMappedValues.Properties"))
{
if (property.first == "Property")
{
AnimaString name = property.second.get<AnimaString>("Name");
AnimaString type = property.second.get<AnimaString>("Type");
if(type == "bool")
{
bool value = property.second.get<bool>("Value");
SetBoolean(name, value);
}
else if(type == "float")
{
AFloat value = property.second.get<AFloat>("Value");
SetFloat(name, value);
}
else if(type == "integer")
{
AInt value = property.second.get<AInt>("Value");
SetInteger(name, value);
}
else if(type == "matrix")
{
AnimaMatrix value = property.second.get<AnimaMatrix>("Value");
SetMatrix(name, value);
}
else if(type == "vector")
{
for(auto& valueTree : property.second.get_child("Value"))
{
if(valueTree.first == "AnimaVectorGenerator")
{
ptree generatorTree;
generatorTree.add_child("AnimaVectorGenerator", valueTree.second);
AnimaString generatorName = _uniqueName + generatorTree.get<AnimaString>("AnimaVectorGenerator.Name");
AnimaVectorGenerator* generator = _dataGeneratorManager->GetDataGeneratorOfTypeFromName<AnimaVectorGenerator>(generatorName);
if(generator == nullptr)
generator = _dataGeneratorManager->CreateVectorGenerator(generatorName);
if(generator)
{
if(!generator->ReadObject(generatorTree, scene, false))
return false;
generator->SetGeneratedFromMappedValues(true);
SetVector(name, generator);
}
}
}
}
else if(type == "color")
{
for(auto& valueTree : property.second.get_child("Value"))
{
if(valueTree.first == "AnimaColorGenerator")
{
ptree generatorTree;
generatorTree.add_child("AnimaColorGenerator", valueTree.second);
AnimaString generatorName = _uniqueName + generatorTree.get<AnimaString>("AnimaColorGenerator.Name");
AnimaColorGenerator* generator = _dataGeneratorManager->GetDataGeneratorOfTypeFromName<AnimaColorGenerator>(generatorName);
if(generator == nullptr)
generator = _dataGeneratorManager->CreateColorGenerator(generatorName);
if(generator)
{
if(!generator->ReadObject(generatorTree, scene, false))
return false;
generator->SetGeneratedFromMappedValues(true);
SetColor(name, generator);
}
}
}
}
else if(type == "texture")
{
for(auto& valueTree : property.second.get_child("Value"))
{
if(valueTree.first == "AnimaTextureGenerator")
{
ptree generatorTree;
generatorTree.add_child("AnimaTextureGenerator", valueTree.second);
AnimaString generatorName = _uniqueName + generatorTree.get<AnimaString>("AnimaTextureGenerator.Name");
AnimaTextureGenerator* generator = _dataGeneratorManager->GetDataGeneratorOfTypeFromName<AnimaTextureGenerator>(generatorName);
if(generator == nullptr)
generator = _dataGeneratorManager->CreateTextureGenerator(generatorName);
if(generator)
{
if(!generator->ReadObject(generatorTree, scene, false))
return false;
generator->SetGeneratedFromMappedValues(true);
SetTexture(name, generator);
}
}
}
}
}
}
ptree namedObjectTree = objectTree.get_child("AnimaMappedValues.NamedObject");
return AnimaNamedObject::ReadObject(namedObjectTree, scene, false);
}
catch (boost::property_tree::ptree_bad_path& exception)
{
AnimaLogger::LogMessageFormat("ERROR - Error parsing mapped values: %s", exception.what());
return false;
}
catch (boost::property_tree::ptree_bad_data& exception)
{
AnimaLogger::LogMessageFormat("ERROR - Error parsing mapped values: %s", exception.what());
return false;
}
}
//============================================================
// <T>添加指定列上的一项数据。</T>
//
// @param pName 列的名称。
// @param value 格子上的值。
//============================================================
void FCsvLine::PutBoolean(TCharC* pName, TBool value){
TInt index = _pHeads->IndexOf(pName);
SetBoolean(index, value);
}
static int ListboxAllowItemClick (lua_State * L)
{
return SetBoolean(L, Listbox_AllowItemClick);
}
static int ListboxAllowDragOver (lua_State * L)
{
return SetBoolean(L, Listbox_AllowDragOver);
}
CCharVariable& CCharVariable::operator =(const bool Value)
{
SetBoolean(Value);
return *this;
}
static int RadioboxAllowClick (lua_State * L)
{
return SetBoolean(L, Radiobox_AllowClick);
}
static int TextboxAllowSpotClick (lua_State * L)
{
return SetBoolean(L, Textbox_AllowSpotClick);
}
static int SliderAllowThumbDrag (lua_State * L)
{
return SetBoolean(L, Slider_AllowThumbDrag);
}
LJValue::LJValue(const LJBool& b) : _type(LJ_NULL)
{
SetBoolean(b);
}
