PSRETURN CMapSummaryReader::LoadMap(const VfsPath& pathname)
{
VfsPath filename_xml = pathname.ChangeExtension(L".xml");
CXeromyces xmb_file;
if (xmb_file.Load(g_VFS, filename_xml) != PSRETURN_OK)
return PSRETURN_File_ReadFailed;
// Define all the relevant elements used in the XML file
#define EL(x) int el_##x = xmb_file.GetElementID(#x)
#define AT(x) int at_##x = xmb_file.GetAttributeID(#x)
EL(scenario);
EL(scriptsettings);
#undef AT
#undef EL
XMBElement root = xmb_file.GetRoot();
ENSURE(root.GetNodeName() == el_scenario);
XERO_ITER_EL(root, child)
{
int child_name = child.GetNodeName();
if (child_name == el_scriptsettings)
{
m_ScriptSettings = child.GetText();
}
}
GLvoid * ELI(SV * sv, GLsizei width, GLsizei height,
GLenum format, GLenum type, int mode)
{
int needlen = 0;
if (!SvROK(sv)) /* don't calc length if arg is a perl ref */
needlen = gl_pixelbuffer_size(format, width, height, type, mode);
return EL(sv, needlen);
}
int main(int argc, char * argv[])
{
try
{
libmaus2::util::ArgInfo const arginfo(argc,argv);
std::vector< std::pair<std::string,std::string> > V;
for ( uint64_t i = 0; i+1 < arginfo.restargs.size(); i += 2 )
{
std::string const sgeneA = arginfo.getUnparsedRestArg(i+0);
std::string const sgeneB = arginfo.getUnparsedRestArg(i+1);
V.push_back(std::pair<std::string,std::string>(sgeneA,sgeneB));
}
libmaus2::lz::PlainOrGzipStream PFIS(std::cin);
std::ostream * postr = &std::cout;
libmaus2::lz::GzipOutputStream::unique_ptr_type PGZOS;
if ( arginfo.hasArg("gz" ) )
{
int const level = arginfo.getValue<int>("level",Z_DEFAULT_COMPRESSION);
libmaus2::lz::GzipOutputStream::unique_ptr_type TGZOS(new libmaus2::lz::GzipOutputStream(std::cout,64*1024,level));
PGZOS = UNIQUE_PTR_MOVE(TGZOS);
postr = PGZOS.get();
}
std::ostream & out = *postr;
while ( PFIS )
{
if ( PFIS.peek() < 0 )
break;
EvidenceList EL(PFIS);
bool ok = false;
for ( uint64_t i = 0; i < V.size(); ++i )
ok = ok || EL.filterGenePair(V[i].first,V[i].second);
if ( ok )
out << EL;
}
PGZOS.reset();
}
catch(std::exception const & ex)
{
std::cerr << ex.what() << std::endl;
return EXIT_FAILURE;
}
}
int Mp3Decoder::init(sh_audio_t *sh_audio)
{
mad_decoder_t *mad_dec = (mad_decoder_t *) sh_audio->context;
mad_dec->have_frame = 0;
//mad_dec->have_frame=read_frame(sh_audio);
//if(!mad_dec->have_frame) return 0; // failed to sync...
//sh_audio->channels=(mad_dec->frame.header.mode == MAD_MODE_SINGLE_CHANNEL) ? 1 : 2;
//sh_audio->samplerate=mad_dec->frame.header.samplerate;
//sh_audio->i_bps=mad_dec->frame.header.bitrate/8;
sh_audio->samplesize=2;
EL("channels: %d, bitrate: %d",sh_audio->channels,sh_audio->i_bps);
return 1;
}
main ()
{
ED();
SGR(CLEAR,WHITE,BLACK+BACK);
printf("PROVA");
SGR(UNDER,RED,BLACK+BACK);
printf("PROVA");
SGR(4,32,40);
printf("PROVA");
SGR(5,33,40);
printf("PROVA");
SGR(7,34,40);
printf("PROVA");
CUP(10,10);
printf("1,10");
CUP(10,20);
printf("10,1");
HVP(15,60);
EL();
printf("PROVA");
SGR(0,0,0);
}
int Mp3Decoder::decode_audio(sh_audio_t *sh_audio,unsigned char **inbuf,int *inlen,unsigned char* outbuf,int *outlen)
{
mad_decoder_t *mad_dec = (mad_decoder_t *) sh_audio->context;
int consume;
*outlen=0;
if(sh_audio->ds && sh_audio->ds->seek_flag > 0){
mad_stream_init (&mad_dec->stream);
a_in_buffer_len = 0;
sh_audio->ds->seek_flag = 0;
}
//if(*inlen == 0)
// return 0;
memcpy(buffer + a_in_buffer_len,*inbuf,*inlen);
a_in_buffer_len += *inlen;
*inbuf += *inlen;
*inlen = 0;
EL("a_in_buffer_len: %d",a_in_buffer_len);
consume = decode_frame(sh_audio,outbuf,outlen);
return *outlen;
}
void operator()(edge_type const * pa, uint64_t const n)
{
EL(pa,n);
}
bool CShaderManager::NewProgram(const char* name, const CShaderDefines& baseDefines, CShaderProgramPtr& program)
{
PROFILE2("loading shader");
PROFILE2_ATTR("name: %s", name);
if (strncmp(name, "fixed:", 6) == 0)
{
program = CShaderProgramPtr(CShaderProgram::ConstructFFP(name+6, baseDefines));
if (!program)
return false;
program->Reload();
return true;
}
VfsPath xmlFilename = L"shaders/" + wstring_from_utf8(name) + L".xml";
CXeromyces XeroFile;
PSRETURN ret = XeroFile.Load(g_VFS, xmlFilename);
if (ret != PSRETURN_OK)
return false;
#if USE_SHADER_XML_VALIDATION
{
TIMER_ACCRUE(tc_ShaderValidation);
// Serialize the XMB data and pass it to the validator
XML_Start();
XML_SetPrettyPrint(false);
XML_WriteXMB(XeroFile);
bool ok = m_Validator.ValidateEncoded(wstring_from_utf8(name), XML_GetOutput());
if (!ok)
return false;
}
#endif
// Define all the elements and attributes used in the XML file
#define EL(x) int el_##x = XeroFile.GetElementID(#x)
#define AT(x) int at_##x = XeroFile.GetAttributeID(#x)
EL(attrib);
EL(define);
EL(fragment);
EL(stream);
EL(uniform);
EL(vertex);
AT(file);
AT(if);
AT(loc);
AT(name);
AT(semantics);
AT(type);
AT(value);
#undef AT
#undef EL
CPreprocessorWrapper preprocessor;
preprocessor.AddDefines(baseDefines);
XMBElement Root = XeroFile.GetRoot();
bool isGLSL = (Root.GetAttributes().GetNamedItem(at_type) == "glsl");
VfsPath vertexFile;
VfsPath fragmentFile;
CShaderDefines defines = baseDefines;
std::map<CStrIntern, int> vertexUniforms;
std::map<CStrIntern, CShaderProgram::frag_index_pair_t> fragmentUniforms;
std::map<CStrIntern, int> vertexAttribs;
int streamFlags = 0;
XERO_ITER_EL(Root, Child)
{
if (Child.GetNodeName() == el_define)
{
defines.Add(CStrIntern(Child.GetAttributes().GetNamedItem(at_name)), CStrIntern(Child.GetAttributes().GetNamedItem(at_value)));
}
else if (Child.GetNodeName() == el_vertex)
{
vertexFile = L"shaders/" + Child.GetAttributes().GetNamedItem(at_file).FromUTF8();
XERO_ITER_EL(Child, Param)
{
XMBAttributeList Attrs = Param.GetAttributes();
CStr cond = Attrs.GetNamedItem(at_if);
if (!cond.empty() && !preprocessor.TestConditional(cond))
continue;
if (Param.GetNodeName() == el_uniform)
{
vertexUniforms[CStrIntern(Attrs.GetNamedItem(at_name))] = Attrs.GetNamedItem(at_loc).ToInt();
}
else if (Param.GetNodeName() == el_stream)
{
CStr StreamName = Attrs.GetNamedItem(at_name);
if (StreamName == "pos")
streamFlags |= STREAM_POS;
else if (StreamName == "normal")
streamFlags |= STREAM_NORMAL;
else if (StreamName == "color")
streamFlags |= STREAM_COLOR;
else if (StreamName == "uv0")
streamFlags |= STREAM_UV0;
else if (StreamName == "uv1")
streamFlags |= STREAM_UV1;
else if (StreamName == "uv2")
streamFlags |= STREAM_UV2;
else if (StreamName == "uv3")
streamFlags |= STREAM_UV3;
}
else if (Param.GetNodeName() == el_attrib)
{
int attribLoc = ParseAttribSemantics(Attrs.GetNamedItem(at_semantics));
vertexAttribs[CStrIntern(Attrs.GetNamedItem(at_name))] = attribLoc;
}
}
}
PcmDecoder::~PcmDecoder()
{
EL("");
free(buffer);
}
void operator()(edge_type const * pa, uint64_t const n)
{
lock.lock();
EL(pa,n);
lock.unlock();
}
int main(int args, char **argv)
{ int size, MyP, i, j, v, k, d, p;
int *index, *edges;
MPI_Comm comm_gr;
MPI_Status status;
struct timeval tv1, tv2;
int dt1;
int reord = 1;
/* Инициализация библиотеки */
MPI_Init(&args, &argv);
/* Каждая ветвь узнает размер системы */
MPI_Comm_size(MPI_COMM_WORLD, &size);
/* и свой номер (ранг) */
MPI_Comm_rank(MPI_COMM_WORLD, &MyP);
/* Выделяем память под массивы для описания вершин и ребер в топологии
* полный граф */
index = (int *)malloc(size * sizeof(int));
edges = (int *)malloc(size*(size-1) * sizeof(int));
/* Заполняем массивы для описания вершин и ребер для топологии
* полный граф и задаем топологию "полный граф". */
for(i = 0; i < size; i++)
{ index[i] = (size - 1)*(i + 1);
v = 0;
for(j = 0; j < size; j++)
{ if(i != j)
edges[i * (size - 1) + v++] = j;
}
}
MPI_Graph_create(MPI_COMM_WORLD, size, index, edges, reord, &comm_gr);
/* Каждая ветвь генерирует свою полосу матрицы A и свой отрезок вектора
* правой части, который присоединяется дополнительным столбцом к A.
* Нулевая ветвь генерирует нулевую полосу, первая ветвь - первую полосу
* и т.д. (По диагонали исходной матрицы - числа = 2, остальные числа = 1). */
for(i = 0; i < N; i++)
{ for(j = 0; j < M; j++)
{ if((N*MyP+i) == j)
MA[i][j] = 2.0;
else
MA[i][j] = 1.0;
}
MA[i][M] = 1.0*(M)+1.0;
}
/* Каждая ветвь засекает начало вычислений и производит вычисления */
gettimeofday(&tv1, (struct timezone*)0);
/* Прямой ход */
/* Цикл p - цикл по компьютерам. Все ветви, начиная с нулевой, последовательно
* приводят к диагональному виду свои строки. Ветвь, приводящая свои строки
* к диагональному виду, назовем активной, строка, с которой производятся
* вычисления, так же назовем активной. */
for(p = 0; p < size; p++)
{
/* Цикл k - цикл по строкам. (Все веиви "крутят" этот цикл). */
for(k = 0; k < N; k++)
{ if(MyP == p)
{
/* Активная ветвь с номером MyP == p приводит свои строки к
* диагональному виду.
* Активная строка k передается ветвям, с номером большим чем MyP */
MAD = 1.0/MA[k][N*p+k];
for(j = M; j >= N*p+k; j--)
MA[k][j] = MA[k][j] * MAD;
for(d = p+1; d < size; d++)
MPI_Send(&MA[k][0], M+1, MPI_DOUBLE, d, tegD, comm_gr);
for(i = k+1; i < N; i++)
{ for(j = M; j >= N*p+k; j--)
MA[i][j] = MA[i][j]-MA[i][N*p+k]*MA[k][j];
}
}
/* Работа принимающих ветвей с номерами MyP > p */
else if(MyP > p)
{ MPI_Recv(V, EL(V), MPI_DOUBLE, p, tegD, comm_gr, &status);
for(i = 0; i < N; i++)
{ for(j = M; j >= N*p+k; j--)
MA[i][j] = MA[i][j]-MA[i][N*p+k]*V[j];
}
}
} /* for k */
} /* for p */
/* Обратный ход */
/* Циклы по p и k аноалогичны, как и при прямом ходе. */
for(p = size-1; p >= 0; p--)
{ for(k = N-1; k >= 0; k--)
{
/* Работа активной ветви */
if(MyP == p)
{ for(d = p-1; d >= 0; d--)
MPI_Send(&MA[k][M], 1, MPI_DOUBLE, d, tegD, comm_gr);
for(i = k-1; i >= 0; i--)
MA[i][M] -= MA[k][M]*MA[i][N*p+k];
}
/* Работа ветвей с номерами MyP < p */
else
{ if(MyP < p)
{ MPI_Recv(&R, 1, MPI_DOUBLE, p, tegD, comm_gr, &status);
for(i = N-1; i >= 0; i--)
MA[i][M] -= R*MA[i][N*p+k];
}
}
} /* for k */
} /* for p */
/* Все ветви засекают время и печатают */
gettimeofday(&tv2, (struct timezone*)0);
dt1 = (tv2.tv_sec - tv1.tv_sec)*1000000 + tv2.tv_usec - tv1.tv_usec;
printf("MyP = %d Time = %d\n", MyP, dt1);
/* Все ветви печатают, для контроля, свои первые четыре значения корня */
printf("MyP = %d %f %f %f %f\n",MyP,MA[0][M],MA[1][M],MA[2][M],MA[3][M]);
/* Все ветви завершают выполнение */
MPI_Finalize();
return(0);
}
bool CShaderManager::NewProgram(const char* name, const std::map<CStr, CStr>& baseDefines, CShaderProgramPtr& program)
{
if (strncmp(name, "fixed:", 6) == 0)
{
program = CShaderProgramPtr(CShaderProgram::ConstructFFP(name+6));
if (!program)
return false;
program->Reload();
return true;
}
VfsPath xmlFilename = L"shaders/" + wstring_from_utf8(name) + L".xml";
CXeromyces XeroFile;
PSRETURN ret = XeroFile.Load(g_VFS, xmlFilename);
if (ret != PSRETURN_OK)
return false;
#if USE_SHADER_XML_VALIDATION
{
TIMER_ACCRUE(tc_ShaderValidation);
// Serialize the XMB data and pass it to the validator
XML_Start();
XML_SetPrettyPrint(false);
XML_WriteXMB(XeroFile);
bool ok = m_Validator.ValidateEncoded(wstring_from_utf8(name), XML_GetOutput());
if (!ok)
return false;
}
#endif
// Define all the elements and attributes used in the XML file
#define EL(x) int el_##x = XeroFile.GetElementID(#x)
#define AT(x) int at_##x = XeroFile.GetAttributeID(#x)
EL(vertex);
EL(fragment);
EL(define);
EL(uniform);
EL(attrib);
EL(stream);
AT(type);
AT(file);
AT(name);
AT(value);
AT(loc);
#undef AT
#undef EL
XMBElement Root = XeroFile.GetRoot();
bool isGLSL = (Root.GetAttributes().GetNamedItem(at_type) == "glsl");
VfsPath vertexFile;
VfsPath fragmentFile;
std::map<CStr, CStr> defines = baseDefines;
std::map<CStr, int> vertexUniforms;
std::map<CStr, int> fragmentUniforms;
int streamFlags = 0;
XERO_ITER_EL(Root, Child)
{
if (Child.GetNodeName() == el_define)
{
defines[Child.GetAttributes().GetNamedItem(at_name)] = Child.GetAttributes().GetNamedItem(at_value);
}
else if (Child.GetNodeName() == el_vertex)
{
vertexFile = L"shaders/" + Child.GetAttributes().GetNamedItem(at_file).FromUTF8();
XERO_ITER_EL(Child, Param)
{
if (Param.GetNodeName() == el_uniform)
{
vertexUniforms[Param.GetAttributes().GetNamedItem(at_name)] = Param.GetAttributes().GetNamedItem(at_loc).ToInt();
}
else if (Param.GetNodeName() == el_stream)
{
CStr StreamName = Param.GetAttributes().GetNamedItem(at_name);
if (StreamName == "pos")
streamFlags |= STREAM_POS;
else if (StreamName == "normal")
streamFlags |= STREAM_NORMAL;
else if (StreamName == "color")
streamFlags |= STREAM_COLOR;
else if (StreamName == "uv0")
streamFlags |= STREAM_UV0;
else if (StreamName == "uv1")
streamFlags |= STREAM_UV1;
else if (StreamName == "uv2")
streamFlags |= STREAM_UV2;
else if (StreamName == "uv3")
streamFlags |= STREAM_UV3;
}
else if (Param.GetNodeName() == el_attrib)
{
// TODO: add support for vertex attributes
}
}
}
else if (Child.GetNodeName() == el_fragment)
bool CSoundGroup::LoadSoundGroup(const VfsPath& pathnameXML)
{
CXeromyces XeroFile;
if (XeroFile.Load(g_VFS, pathnameXML) != PSRETURN_OK)
{
HandleError(L"error loading file", pathnameXML, ERR::FAIL);
return false;
}
// Define elements used in XML file
#define EL(x) int el_##x = XeroFile.GetElementID(#x)
#define AT(x) int at_##x = XeroFile.GetAttributeID(#x)
EL(soundgroup);
EL(gain);
EL(looping);
EL(omnipresent);
EL(distanceless);
EL(pitch);
EL(priority);
EL(randorder);
EL(randgain);
EL(randpitch);
EL(conegain);
EL(coneinner);
EL(coneouter);
EL(sound);
EL(gainupper);
EL(gainlower);
EL(pitchupper);
EL(pitchlower);
EL(path);
EL(threshold);
EL(decay);
#undef AT
#undef EL
XMBElement root = XeroFile.GetRoot();
if (root.GetNodeName() != el_soundgroup)
{
LOGERROR(L"Invalid SoundGroup format (unrecognised root element '%hs')", XeroFile.GetElementString(root.GetNodeName()).c_str());
return false;
}
XERO_ITER_EL(root, child)
{
int child_name = child.GetNodeName();
if(child_name == el_gain)
{
SetGain(child.GetText().ToFloat());
}
else if(child_name == el_looping)
{
if(child.GetText().ToInt() == 1)
SetFlag(eLoop);
}
else if(child_name == el_omnipresent)
{
if(child.GetText().ToInt() == 1)
SetFlag(eOmnipresent);
}
else if(child_name == el_distanceless)
{
if(child.GetText().ToInt() == 1)
SetFlag(eDistanceless);
}
else if(child_name == el_pitch)
{
this->m_Pitch = child.GetText().ToFloat();
}
else if(child_name == el_priority)
{
this->m_Priority = child.GetText().ToFloat();
}
else if(child_name == el_randorder)
{
if(child.GetText().ToInt() == 1)
SetFlag(eRandOrder);
}
else if(child_name == el_randgain)
{
if(child.GetText().ToInt() == 1)
SetFlag(eRandGain);
}
else if(child_name == el_gainupper)
{
this->m_GainUpper = child.GetText().ToFloat();
}
else if(child_name == el_gainlower)
{
this->m_GainLower = child.GetText().ToFloat();
}
else if(child_name == el_randpitch)
{
if(child.GetText().ToInt() == 1)
SetFlag(eRandPitch);
}
else if(child_name == el_pitchupper)
{
this->m_PitchUpper = child.GetText().ToFloat();
}
else if(child_name == el_pitchlower)
{
this->m_PitchLower = child.GetText().ToFloat();
}
else if(child_name == el_conegain)
{
this->m_ConeOuterGain = child.GetText().ToFloat();
}
else if(child_name == el_coneinner)
{
this->m_ConeInnerAngle = child.GetText().ToFloat();
}
else if(child_name == el_coneouter)
{
this->m_ConeOuterAngle = child.GetText().ToFloat();
}
else if(child_name == el_sound)
{
this->filenames.push_back(child.GetText().FromUTF8());
}
else if(child_name == el_path)
{
m_filepath = child.GetText().FromUTF8();
}
else if(child_name == el_threshold)
{
m_IntensityThreshold = child.GetText().ToFloat();
}
else if(child_name == el_decay)
{
m_Decay = child.GetText().ToFloat();
}
}
INT WINAPI wWinMain( HINSTANCE hInst, HINSTANCE, LPWSTR, INT ) // 프로그램 진입점
{
WNDCLASSEX wc = // 윈도우 클래스 정의,등록
{
sizeof( WNDCLASSEX ), CS_CLASSDC, MsgProc, 0L, 0L,
GetModuleHandle( NULL ), NULL, NULL, NULL, NULL,
"ProG", NULL
};
RegisterClassEx( &wc );
HWND hWnd = CreateWindow( "ProG", "ProG", // 윈도우 생성
WS_BORDER | WS_SYSMENU, 0, 0, 1680, 1030, //// 좌표 변수 처리
NULL, NULL, wc.hInstance, NULL );
CDevice::GetInstance()->Init(hWnd, 1680, 1030);
if( SUCCEEDED( InitD3D( hWnd ) ) ) // Direct3D초기화
{
ShowWindow( hWnd, SW_SHOWDEFAULT ); // 윈도우 출력
UpdateWindow( hWnd );
MSG msg;
while(true) // 메시지 루프
{
if(PeekMessage(&msg, NULL,NULL, NULL, PM_REMOVE))
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
else
{
first_time = GetTickCount();
if(g_Load.Logo_Start == true)
{
Loading();
if(g_Load.Out_Exit() == true)
{
PostQuitMessage( 0 );
}
}
if(g_Load.Logo_Start == false)
{
Update();
Destroy();
Active();
Collision();
Create();
Stage1();
EL();
World_Time = World_Time + tick;
}
Render();
tick = (float)(GetTickCount() - first_time)/(float)1000;
}
if(msg.message == WM_QUIT)
{
break;
}
}
}
Cleanup();
UnregisterClass( "ProG", wc.hInstance ); // 등록된 클래스 소거
return 0;
}
CTextureConverter::SettingsFile* CTextureConverter::LoadSettings(const VfsPath& path) const
{
CXeromyces XeroFile;
if (XeroFile.Load(m_VFS, path) != PSRETURN_OK)
return NULL;
// Define all the elements used in the XML file
#define EL(x) int el_##x = XeroFile.GetElementID(#x)
#define AT(x) int at_##x = XeroFile.GetAttributeID(#x)
EL(textures);
EL(file);
AT(pattern);
AT(format);
AT(mipmap);
AT(normal);
AT(alpha);
AT(filter);
AT(kaiserwidth);
AT(kaiseralpha);
AT(kaiserstretch);
#undef AT
#undef EL
XMBElement root = XeroFile.GetRoot();
if (root.GetNodeName() != el_textures)
{
LOGERROR("Invalid texture settings file \"%s\" (unrecognised root element)", path.string8());
return NULL;
}
std::unique_ptr<SettingsFile> settings(new SettingsFile());
XERO_ITER_EL(root, child)
{
if (child.GetNodeName() == el_file)
{
Match p;
XERO_ITER_ATTR(child, attr)
{
if (attr.Name == at_pattern)
{
p.pattern = attr.Value.FromUTF8();
}
else if (attr.Name == at_format)
{
CStr v(attr.Value);
if (v == "dxt1")
p.settings.format = FMT_DXT1;
else if (v == "dxt3")
p.settings.format = FMT_DXT3;
else if (v == "dxt5")
p.settings.format = FMT_DXT5;
else if (v == "rgba")
p.settings.format = FMT_RGBA;
else if (v == "alpha")
p.settings.format = FMT_ALPHA;
else
LOGERROR("Invalid attribute value <file format='%s'>", v.c_str());
}
else if (attr.Name == at_mipmap)
{
CStr v(attr.Value);
if (v == "true")
p.settings.mipmap = MIP_TRUE;
else if (v == "false")
p.settings.mipmap = MIP_FALSE;
else
LOGERROR("Invalid attribute value <file mipmap='%s'>", v.c_str());
}
else if (attr.Name == at_normal)
{
CStr v(attr.Value);
if (v == "true")
p.settings.normal = NORMAL_TRUE;
else if (v == "false")
p.settings.normal = NORMAL_FALSE;
else
LOGERROR("Invalid attribute value <file normal='%s'>", v.c_str());
}
else if (attr.Name == at_alpha)
{
CStr v(attr.Value);
if (v == "none")
p.settings.alpha = ALPHA_NONE;
else if (v == "player")
p.settings.alpha = ALPHA_PLAYER;
else if (v == "transparency")
p.settings.alpha = ALPHA_TRANSPARENCY;
else
LOGERROR("Invalid attribute value <file alpha='%s'>", v.c_str());
}
else if (attr.Name == at_filter)
{
CStr v(attr.Value);
if (v == "box")
p.settings.filter = FILTER_BOX;
else if (v == "triangle")
p.settings.filter = FILTER_TRIANGLE;
else if (v == "kaiser")
p.settings.filter = FILTER_KAISER;
else
LOGERROR("Invalid attribute value <file filter='%s'>", v.c_str());
}
else if (attr.Name == at_kaiserwidth)
{
p.settings.kaiserWidth = CStr(attr.Value).ToFloat();
}
else if (attr.Name == at_kaiseralpha)
{
p.settings.kaiserAlpha = CStr(attr.Value).ToFloat();
}
else if (attr.Name == at_kaiserstretch)
{
p.settings.kaiserStretch = CStr(attr.Value).ToFloat();
}
else
{
LOGERROR("Invalid attribute name <file %s='...'>", XeroFile.GetAttributeString(attr.Name).c_str());
}
}
settings->patterns.push_back(p);
}
}
CMaterial& CMaterialManager::LoadMaterial(const VfsPath& pathname)
{
if(pathname.empty())
return NullMaterial;
std::map<VfsPath, CMaterial*>::iterator iter = m_Materials.find(pathname);
if(iter != m_Materials.end())
{
if((*iter).second)
return *(*iter).second;
}
CXeromyces xeroFile;
if(xeroFile.Load(g_VFS, pathname) != PSRETURN_OK)
return NullMaterial;
#define EL(x) int el_##x = xeroFile.GetElementID(#x)
#define AT(x) int at_##x = xeroFile.GetAttributeID(#x)
EL(texture);
EL(alpha);
AT(usage);
#undef AT
#undef EL
CMaterial *material = NULL;
try
{
XMBElement root = xeroFile.GetRoot();
XMBElementList childNodes = root.GetChildNodes();
material = new CMaterial();
for(int i = 0; i < childNodes.Count; i++)
{
XMBElement node = childNodes.Item(i);
int token = node.GetNodeName();
XMBAttributeList attrs = node.GetAttributes();
CStr temp;
if(token == el_texture)
{
CStr value(node.GetText());
material->SetTexture(value);
}
else if(token == el_alpha)
{
temp = CStr(attrs.GetNamedItem(at_usage));
// Determine whether the alpha is used for basic transparency or player color
if (temp == "playercolor")
material->SetUsePlayerColor(true);
else if (temp == "objectcolor")
material->SetUseTextureColor(true);
else
material->SetUsesAlpha(ParseUsage(temp));
}
}
m_Materials[pathname] = material;
}
catch(...)
{
SAFE_DELETE(material);
throw;
}
return *material;
}
CMaterial CMaterialManager::LoadMaterial(const VfsPath& pathname)
{
if (pathname.empty())
return CMaterial();
std::map<VfsPath, CMaterial>::iterator iter = m_Materials.find(pathname);
if (iter != m_Materials.end())
return iter->second;
CXeromyces xeroFile;
if (xeroFile.Load(g_VFS, pathname, "material") != PSRETURN_OK)
return CMaterial();
#define EL(x) int el_##x = xeroFile.GetElementID(#x)
#define AT(x) int at_##x = xeroFile.GetAttributeID(#x)
EL(alpha_blending);
EL(alternative);
EL(define);
EL(shader);
EL(uniform);
EL(renderquery);
EL(required_texture);
EL(conditional_define);
AT(effect);
AT(if);
AT(define);
AT(quality);
AT(material);
AT(name);
AT(value);
AT(type);
AT(min);
AT(max);
AT(conf);
#undef AT
#undef EL
CMaterial material;
XMBElement root = xeroFile.GetRoot();
CPreprocessorWrapper preprocessor;
preprocessor.AddDefine("CFG_FORCE_ALPHATEST", g_Renderer.m_Options.m_ForceAlphaTest ? "1" : "0");
CVector4D vec(qualityLevel,0,0,0);
material.AddStaticUniform("qualityLevel", vec);
XERO_ITER_EL(root, node)
{
int token = node.GetNodeName();
XMBAttributeList attrs = node.GetAttributes();
if (token == el_alternative)
{
CStr cond = attrs.GetNamedItem(at_if);
if (cond.empty() || !preprocessor.TestConditional(cond))
{
cond = attrs.GetNamedItem(at_quality);
if (cond.empty())
continue;
else
{
if (cond.ToFloat() <= qualityLevel)
continue;
}
}
material = LoadMaterial(VfsPath("art/materials") / attrs.GetNamedItem(at_material).FromUTF8());
break;
}
else if (token == el_alpha_blending)
{
material.SetUsesAlphaBlending(true);
}
else if (token == el_shader)
{
material.SetShaderEffect(attrs.GetNamedItem(at_effect));
}
else if (token == el_define)
{
material.AddShaderDefine(CStrIntern(attrs.GetNamedItem(at_name)), CStrIntern(attrs.GetNamedItem(at_value)));
}
else if (token == el_conditional_define)
{
std::vector<float> args;
CStr type = attrs.GetNamedItem(at_type).c_str();
int typeID = -1;
if (type == CStr("draw_range"))
{
typeID = DCOND_DISTANCE;
float valmin = -1.0f;
float valmax = -1.0f;
CStr conf = attrs.GetNamedItem(at_conf);
if (!conf.empty())
{
CFG_GET_VAL("materialmgr." + conf + ".min", valmin);
CFG_GET_VAL("materialmgr." + conf + ".max", valmax);
}
else
{
CStr dmin = attrs.GetNamedItem(at_min);
if (!dmin.empty())
valmin = attrs.GetNamedItem(at_min).ToFloat();
CStr dmax = attrs.GetNamedItem(at_max);
if (!dmax.empty())
valmax = attrs.GetNamedItem(at_max).ToFloat();
}
args.push_back(valmin);
args.push_back(valmax);
if (valmin >= 0.0f)
{
std::stringstream sstr;
sstr << valmin;
material.AddShaderDefine(CStrIntern(conf + "_MIN"), CStrIntern(sstr.str()));
}
if (valmax >= 0.0f)
{
std::stringstream sstr;
sstr << valmax;
material.AddShaderDefine(CStrIntern(conf + "_MAX"), CStrIntern(sstr.str()));
}
}
material.AddConditionalDefine(attrs.GetNamedItem(at_name).c_str(),
attrs.GetNamedItem(at_value).c_str(),
typeID, args);
}
else if (token == el_uniform)
{
std::stringstream str(attrs.GetNamedItem(at_value));
CVector4D vec;
str >> vec.X >> vec.Y >> vec.Z >> vec.W;
material.AddStaticUniform(attrs.GetNamedItem(at_name).c_str(), vec);
}
