Macro MacroSet::macro( const QString& name ) const {
Macros::const_iterator it = m_usedMacros.find( Macro( name, "" ) );
if( it != m_usedMacros.end() ) {
return *it;
} else {
return Macro();
}
}
Macro& Driver::macro( const HashedString& name ) {
std::pair< MacroMap::iterator, MacroMap::iterator > range = m_macros.equal_range( name );
if ( range.first == range.second ) {
return ( *m_macros.insert( std::make_pair( deepCopy( name.str() ), Macro() ) ) ).second;
} else {
return ( *( --range.second ) ).second;
}
}
Macro MacroManager::getMacro(int mkey, int gkey)
{
QMutexLocker locker(&mutex);
if(!programs.contains(curActiveId))
return Macro();
return programs.value(curActiveId).value(mgcode(mkey, gkey));
}
bool MacroSet::hasMacro( const HashedString& name ) const {
Macros::const_iterator it = m_usedMacros.find( Macro( name.str(), "" ) );
if( it != m_usedMacros.end() ) {
return true;
} else {
return false;
}
}
void CSmartFieldListBoxItem::RestoreState(void)
{
// Save the state of the item.
if (IsMacroValid())
{
CMacro* pMacro = Macro();
pMacro->MacroValueType(m_nSaveType);
pMacro->Value(m_csSaveValue);
}
}
void CMacroList::DeleteMacro(int nMacro)
{
ASSERT(nMacro < Macros());
if (nMacro < Macros())
{
delete Macro(nMacro);
RemoveAt(nMacro);
}
}
void MacroManager::trySaveMacro(Macro* m, QString curProg, int curMKey, int curGKey)
{
if(m->curEvent > 0)
{
//Save previous macro
writeDbg(tr("Add macro for: ") + curProg + tr(" at M") + QString::number(curMKey) + tr(",G") + QString::number(curGKey) + tr(" with ") + QString::number(m->curEvent) + tr(" events"));
setMacro(curMKey, curGKey, *m);
*m = Macro();
}
}
BOOL CMacroList::SetMacroValue(int nMacro, const CString& csNewValue)
{
if (nMacro < Macros())
{
CMacro* pMacro = Macro(nMacro);
if (pMacro != NULL)
{
pMacro->Value(csNewValue);
return TRUE;
}
}
ASSERT(FALSE);
return FALSE;
}
int main(){
Macro();
int n;for (scanf("%d", &n); n; n--) {
char c; Point_3 p;
scanf("\n%c%lf%lf%lf", &c, &p.x, &p.y, &p.z);
if (c == 'T') Translation(p); if (c == 'S') Scaling(p);
if (c == 'R') { double r;scanf("%lf\n", &r);
Rotate(p, r); //===========绕OP逆时针旋转r角度
}}
for (scanf("%d", &n); n; n--) {
Point_3 p, p2; scanf("%lf%lf%lf", &p.x, &p.y, &p.z);
p2 = opt(p); printf(“%f %f %f\n”,p2.x,p2.y,p2.z);
}
}
CMacro* CMacroList::FindMacro(LPCSTR pName)
{
int nMacros = Macros();
for (int nMacro = 0; nMacro < nMacros; nMacro++)
{
CMacro* pMacro = Macro(nMacro);
if (pMacro->Name() == pName)
{
return pMacro;
}
}
return NULL;
}
void CMacroList::DeleteMacro(LPCSTR pName)
{
int nMacros = Macros();
for (int nMacro = 0; nMacro < nMacros; nMacro++)
{
CMacro* pMacro = Macro(nMacro);
if (pMacro->Name() == pName)
{
DeleteMacro(nMacro);
return;
}
}
}
CMacro* CMacroList::FindMacro(WORD wID)
{
int nMacros = Macros();
for (int nMacro = 0; nMacro < nMacros; nMacro++)
{
CMacro* pMacro = Macro(nMacro);
if (pMacro->Id() == wID)
{
return pMacro;
}
}
return NULL;
}
BOOL CMacroList::GetMacroValue(int nMacro, CString& csValue)
{
/* In case of error. */
csValue.Empty();
if (nMacro < Macros())
{
CMacro* pMacro = Macro(nMacro);
if (pMacro != NULL)
{
csValue = pMacro->Value();
return TRUE;
}
}
ASSERT(FALSE);
return FALSE;
}
void Shader3D_Imp::CompileMass()
{
if (mass_shaders[0] != nullptr) return;
auto g = (Graphics_Imp*) graphics;
std::shared_ptr<NativeShader_Imp> shaders[2];
std::shared_ptr<NativeShader_Imp> shaders_light[2];
std::shared_ptr<NativeShader_Imp> shaders_depth[2];
std::shared_ptr<NativeShader_Imp> shaders_light_depth[2];
for (int32_t i = 0; i < 2; i++)
{
std::vector<asd::VertexLayout> vl;
vl.push_back(asd::VertexLayout("Position", asd::VertexLayoutFormat::R32G32B32_FLOAT));
vl.push_back(asd::VertexLayout("Normal", asd::VertexLayoutFormat::R32G32B32_FLOAT));
vl.push_back(asd::VertexLayout("Binormal", asd::VertexLayoutFormat::R32G32B32_FLOAT));
vl.push_back(asd::VertexLayout("UV", asd::VertexLayoutFormat::R32G32_FLOAT));
vl.push_back(asd::VertexLayout("UVSub", asd::VertexLayoutFormat::R32G32_FLOAT));
vl.push_back(asd::VertexLayout("Color", asd::VertexLayoutFormat::R8G8B8A8_UNORM));
vl.push_back(asd::VertexLayout("BoneWeights", asd::VertexLayoutFormat::R8G8B8A8_UNORM));
vl.push_back(asd::VertexLayout("BoneIndexes", asd::VertexLayoutFormat::R8G8B8A8_UINT));
//vl.push_back(asd::VertexLayout("BoneIndexesOriginal", asd::VertexLayoutFormat::R8G8B8A8_UINT));
std::vector<asd::Macro> macro;
std::vector<asd::Macro> macro_light;
std::vector<asd::Macro> macro_depth;
std::vector<asd::Macro> macro_light_depth;
macro_depth.push_back(Macro("EXPORT_DEPTH", "1"));
macro_light_depth.push_back(Macro("EXPORT_DEPTH", "1"));
macro_light.push_back(Macro("LIGHTWEIGHT", "1"));
macro_light_depth.push_back(Macro("LIGHTWEIGHT", "1"));
if (i == 1)
{
macro.push_back(Macro("ANIMATION_IS_ENABLED", "1"));
macro_light.push_back(Macro("ANIMATION_IS_ENABLED", "1"));
macro_depth.push_back(Macro("ANIMATION_IS_ENABLED", "1"));
macro_light_depth.push_back(Macro("ANIMATION_IS_ENABLED", "1"));
}
if (g->GetGraphicsDeviceType() == GraphicsDeviceType::DirectX11)
{
shaders[i] = g->CreateShader_Imp(
mass_model_internal_vs_dx,
"shader2d_dx_vs",
ToUtf8String(shaderText.c_str()).c_str(),
ToUtf8String(shaderFileName.c_str()).c_str(),
vl,
true,
macro);
shaders_light[i] = g->CreateShader_Imp(
lightweight_mass_model_internal_vs_dx,
"shader2d_dx_vs",
ToUtf8String(shaderText.c_str()).c_str(),
ToUtf8String(shaderFileName.c_str()).c_str(),
vl,
true,
macro_light);
shaders_depth[i] = g->CreateShader_Imp(
mass_model_internal_vs_dx,
"shader2d_dx_vs",
ToUtf8String(shaderText.c_str()).c_str(),
ToUtf8String(shaderFileName.c_str()).c_str(),
vl,
true,
macro_depth);
shaders_light_depth[i] = g->CreateShader_Imp(
lightweight_mass_model_internal_vs_dx,
"shader2d_dx_vs",
ToUtf8String(shaderText.c_str()).c_str(),
ToUtf8String(shaderFileName.c_str()).c_str(),
vl,
true,
macro_light_depth);
}
else if (g->GetGraphicsDeviceType() == GraphicsDeviceType::OpenGL)
{
shaders[i] = g->CreateShader_Imp(
mass_model_internal_vs_gl,
"shader3d_gl_vs",
ToUtf8String(shaderText.c_str()).c_str(),
ToUtf8String(shaderFileName.c_str()).c_str(),
vl,
true,
macro);
shaders_light[i] = g->CreateShader_Imp(
lightweight_mass_model_internal_vs_gl,
"shader3d_gl_vs",
ToUtf8String(shaderText.c_str()).c_str(),
ToUtf8String(shaderFileName.c_str()).c_str(),
vl,
true,
macro_light);
shaders_depth[i] = g->CreateShader_Imp(
mass_model_internal_vs_gl,
"shader3d_gl_vs",
ToUtf8String(shaderText.c_str()).c_str(),
ToUtf8String(shaderFileName.c_str()).c_str(),
vl,
true,
macro_depth);
shaders_light_depth[i] = g->CreateShader_Imp(
lightweight_mass_model_internal_vs_gl,
"shader3d_gl_vs",
ToUtf8String(shaderText.c_str()).c_str(),
ToUtf8String(shaderFileName.c_str()).c_str(),
vl,
true,
macro_light_depth);
}
mass_shaders[i] = shaders[i];
mass_shaders_light[i] = shaders_light[i];
mass_shaders_depth[i] = shaders_depth[i];
mass_shaders_light_depth[i] = shaders_light_depth[i];
}
}
void Driver::setupLexer( Lexer * lexer )
{
// stl
lexer->addSkipWord( "__STL_BEGIN_NAMESPACE" );
lexer->addSkipWord( "__STL_END_NAMESPACE" );
lexer->addSkipWord( "__STL_BEGIN_RELOPS_NAMESPACE" );
lexer->addSkipWord( "__STL_END_RELOPS_NAMESPACE" );
lexer->addSkipWord( "__STL_TEMPLATE_NULL" );
lexer->addSkipWord( "__STL_TRY" );
lexer->addSkipWord( "__STL_UNWIND" );
lexer->addSkipWord( "__STL_NOTHROW" );
lexer->addSkipWord( "__STL_NULL_TMPL_ARGS" );
lexer->addSkipWord( "__STL_UNWIND", SkipWordAndArguments );
lexer->addSkipWord( "__GC_CONST" );
lexer->addSkipWord( "__HASH_ALLOC_INIT", SkipWordAndArguments );
lexer->addSkipWord( "__STL_DEFAULT_ALLOCATOR", SkipWordAndArguments, "T" );
lexer->addSkipWord( "__STL_MUTEX_INITIALIZER" );
lexer->addSkipWord( "__STL_NULL_TMPL_ARGS" );
// antlr
lexer->addSkipWord( "ANTLR_BEGIN_NAMESPACE", SkipWordAndArguments );
lexer->addSkipWord( "ANTLR_USE_NAMESPACE", SkipWordAndArguments );
lexer->addSkipWord( "ANTLR_USING_NAMESPACE", SkipWordAndArguments );
lexer->addSkipWord( "ANTLR_END_NAMESPACE" );
lexer->addSkipWord( "ANTLR_C_USING", SkipWordAndArguments );
lexer->addSkipWord( "ANTLR_API" );
// gnu
lexer->addSkipWord( "__extension__", SkipWordAndArguments );
lexer->addSkipWord( "__attribute__", SkipWordAndArguments );
lexer->addSkipWord( "__BEGIN_DECLS" );
lexer->addSkipWord( "__END_DECLS" );
lexer->addSkipWord( "__THROW" );
lexer->addSkipWord( "__restrict" );
lexer->addSkipWord( "__restrict__" );
lexer->addSkipWord( "__attribute_pure__" );
lexer->addSkipWord( "__attribute_malloc__" );
lexer->addSkipWord( "__attribute_format_strfmon__" );
lexer->addSkipWord( "__asm__", SkipWordAndArguments );
lexer->addSkipWord( "__devinit" );
lexer->addSkipWord( "__devinit__" );
lexer->addSkipWord( "__init" );
lexer->addSkipWord( "__init__" );
lexer->addSkipWord( "__signed" );
lexer->addSkipWord( "__signed__" );
lexer->addSkipWord( "__unsigned" );
lexer->addSkipWord( "__unsigned__" );
lexer->addSkipWord( "asmlinkage" );
lexer->addSkipWord( "____cacheline_aligned" );
lexer->addSkipWord( "__glibcpp_class_requires", SkipWordAndArguments );
lexer->addSkipWord( "__glibcpp_class2_requires", SkipWordAndArguments );
lexer->addSkipWord( "__glibcpp_class4_requires", SkipWordAndArguments );
lexer->addSkipWord( "__glibcpp_function_requires", SkipWordAndArguments );
lexer->addSkipWord( "restrict" );
lexer->addSkipWord( "__BEGIN_NAMESPACE_STD" );
lexer->addSkipWord( "__END_NAMESPACE_STD" );
lexer->addSkipWord( "__BEGIN_NAMESPACE_C99" );
lexer->addSkipWord( "__END_NAMESPACE_C99" );
lexer->addSkipWord( "__USING_NAMESPACE_STD", SkipWordAndArguments );
// kde
lexer->addSkipWord( "K_SYCOCATYPE", SkipWordAndArguments );
lexer->addSkipWord( "EXPORT_DOCKCLASS" );
lexer->addSkipWord( "K_EXPORT_COMPONENT_FACTORY", SkipWordAndArguments );
lexer->addSkipWord( "K_SYCOCAFACTORY", SkipWordAndArguments );
lexer->addSkipWord( "KDE_DEPRECATED" );
// qt
lexer->addSkipWord( "Q_OVERRIDE", SkipWordAndArguments );
lexer->addSkipWord( "Q_ENUMS", SkipWordAndArguments );
lexer->addSkipWord( "Q_PROPERTY", SkipWordAndArguments );
lexer->addSkipWord( "Q_CLASSINFO", SkipWordAndArguments );
lexer->addSkipWord( "Q_SETS", SkipWordAndArguments );
lexer->addSkipWord( "Q_UNUSED", SkipWordAndArguments );
lexer->addSkipWord( "Q_CREATE_INSTANCE", SkipWordAndArguments );
lexer->addSkipWord( "Q_DUMMY_COMPARISON_OPERATOR", SkipWordAndArguments );
lexer->addSkipWord( "ACTIVATE_SIGNAL_WITH_PARAM", SkipWordAndArguments );
lexer->addSkipWord( "Q_INLINE_TEMPLATES" );
lexer->addSkipWord( "Q_TEMPLATE_EXTERN" );
lexer->addSkipWord( "Q_TYPENAME" );
lexer->addSkipWord( "Q_REFCOUNT" );
lexer->addSkipWord( "Q_EXPLICIT" );
lexer->addSkipWord( "QMAC_PASCAL" );
lexer->addSkipWord( "QT_STATIC_CONST" );
lexer->addSkipWord( "QT_STATIC_CONST_IMPL" );
lexer->addSkipWord( "QT_WIN_PAINTER_MEMBERS" );
lexer->addSkipWord( "QT_NC_MSGBOX" );
lexer->addSkipWord( "Q_VARIANT_AS", SkipWordAndArguments );
lexer->addSkipWord( "CALLBACK_CALL_TYPE" );
// flex
lexer->addSkipWord( "yyconst" );
lexer->addSkipWord( "YY_RULE_SETUP" );
lexer->addSkipWord( "YY_BREAK" );
lexer->addSkipWord( "YY_RESTORE_YY_MORE_OFFSET" );
// gtk
lexer->addSkipWord( "G_BEGIN_DECLS" );
lexer->addSkipWord( "G_END_DECLS" );
lexer->addSkipWord( "G_GNUC_CONST" );
lexer->addSkipWord( "G_CONST_RETURN" );
lexer->addSkipWord( "GTKMAIN_C_VAR" );
lexer->addSkipWord( "GTKVAR" );
lexer->addSkipWord( "GDKVAR" );
lexer->addSkipWord( "G_GNUC_PRINTF", SkipWordAndArguments );
// windows
lexer->addSkipWord( "WINAPI" );
lexer->addSkipWord( "__stdcall" );
lexer->addSkipWord( "__cdecl" );
lexer->addSkipWord( "_cdecl" );
lexer->addSkipWord( "CALLBACK" );
// gcc extensions
addMacro( Macro("__asm__", "asm") );
addMacro( Macro("__inline", "inline") );
addMacro( Macro("__inline__", "inline") );
addMacro( Macro("__const", "const") );
addMacro( Macro("__const__", "const") );
addMacro( Macro("__volatile__", "volatile") );
addMacro( Macro("__complex__", "") );
}
// setup the preprocessor
// code provided by Reginald Stadlbauer <*****@*****.**>
void setup()
{
QString kdedir = getenv( "KDEDIR" );
if ( !kdedir.isNull() )
addIncludePath( kdedir + "/include" );
QString qtdir = getenv( "QTDIR" );
if ( !qtdir.isNull() )
addIncludePath( qtdir + "/include" );
QString qmakespec = getenv( "QMAKESPEC" );
if ( qmakespec.isNull() )
qmakespec = "linux-g++";
// #### implement other mkspecs and find a better way to find the
// #### proper mkspec (althoigh this will be no fun :-)
addIncludePath( qtdir + "/mkspecs/" + qmakespec );
if ( qmakespec == "linux-g++" )
{
addIncludePath( "/include" );
addIncludePath( "/usr/include" );
addIncludePath( "/ust/local/include" );
bool ok;
QString gccLibPath = SetupHelper::getGccIncludePath(&ok);
if (!ok)
return;
gccLibPath = gccLibPath.replace( QRegExp( "[\r\n]" ), "" );
addIncludePath( gccLibPath );
addIncludePath( "/usr/include/g++-3" );
addIncludePath( "/usr/include/g++" );
QStringList lines = SetupHelper::getGccMacros(&ok);
if (!ok)
return;
for (QStringList::ConstIterator it = lines.constBegin(); it != lines.constEnd(); ++it) {
QStringList lst = QStringList::split( ' ', *it );
if ( lst.count() != 3 )
continue;
addMacro( Macro( lst[1], lst[2] ) );
}
addMacro( Macro( "__cplusplus", "1" ) );
QString incl = getenv( "INCLUDE" );
QStringList includePaths = QStringList::split( ':', incl );
QStringList::Iterator it = includePaths.begin();
while ( it != includePaths.end() )
{
addIncludePath( ( *it ).stripWhiteSpace() );
++it;
}
}
else if ( qmakespec == "win32-borland" )
{
QString incl = getenv( "INCLUDE" );
QStringList includePaths = QStringList::split( ';', incl );
QStringList::Iterator it = includePaths.begin();
while ( it != includePaths.end() )
{
addIncludePath( ( *it ).stripWhiteSpace() );
++it;
}
// ### I am sure there are more standard include paths on
// ### windows. I will fix that soon
// ### Also do the compiler specific defines on windows
}
}
void Shader3D_Imp::CompileTerrain()
{
if (terrain_shader != nullptr) return;
auto g = (Graphics_Imp*) graphics;
std::shared_ptr<NativeShader_Imp> shader;
std::shared_ptr<NativeShader_Imp> shader_light;
std::vector<asd::VertexLayout> vl;
vl.push_back(asd::VertexLayout("Position", asd::VertexLayoutFormat::R32G32B32_FLOAT));
vl.push_back(asd::VertexLayout("Normal", asd::VertexLayoutFormat::R32G32B32_FLOAT));
vl.push_back(asd::VertexLayout("Binormal", asd::VertexLayoutFormat::R32G32B32_FLOAT));
vl.push_back(asd::VertexLayout("UV", asd::VertexLayoutFormat::R32G32_FLOAT));
vl.push_back(asd::VertexLayout("UVSub", asd::VertexLayoutFormat::R32G32_FLOAT));
vl.push_back(asd::VertexLayout("Color", asd::VertexLayoutFormat::R8G8B8A8_UNORM));
//vl.push_back(asd::VertexLayout("BoneWeights", asd::VertexLayoutFormat::R8G8B8A8_UNORM));
//vl.push_back(asd::VertexLayout("BoneIndexes", asd::VertexLayoutFormat::R8G8B8A8_UINT));
//vl.push_back(asd::VertexLayout("BoneIndexesOriginal", asd::VertexLayoutFormat::R8G8B8A8_UINT));
std::vector<asd::Macro> macro;
std::vector<asd::Macro> macro_light;
macro_light.push_back(Macro("LIGHTWEIGHT", "1"));
if (g->GetGraphicsDeviceType() == GraphicsDeviceType::DirectX11)
{
shader = g->CreateShader_Imp(
terrain_internal_vs_dx,
"shader2d_dx_vs",
ToUtf8String(shaderText.c_str()).c_str(),
ToUtf8String(shaderFileName.c_str()).c_str(),
vl,
true,
macro);
shader_light = g->CreateShader_Imp(
lightweight_terrain_internal_vs_dx,
"shader2d_dx_vs",
ToUtf8String(shaderText.c_str()).c_str(),
ToUtf8String(shaderFileName.c_str()).c_str(),
vl,
true,
macro_light);
}
else if (g->GetGraphicsDeviceType() == GraphicsDeviceType::OpenGL)
{
shader = g->CreateShader_Imp(
terrain_internal_vs_gl,
"shader3d_gl_vs",
ToUtf8String(shaderText.c_str()).c_str(),
ToUtf8String(shaderFileName.c_str()).c_str(),
vl,
true,
macro);
shader_light = g->CreateShader_Imp(
lightweight_terrain_internal_vs_gl,
"shader3d_gl_vs",
ToUtf8String(shaderText.c_str()).c_str(),
ToUtf8String(shaderFileName.c_str()).c_str(),
vl,
true,
macro_light);
}
terrain_shader = shader;
terrain_shader_light = shader_light;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
Shader3D_Imp* Shader3D_Imp::Create(
Graphics* graphics,
const achar* shaderText,
const achar* shaderFileName,
Log* log)
{
auto g = (Graphics_Imp*) graphics;
std::shared_ptr<NativeShader_Imp> shader;
std::shared_ptr<NativeShader_Imp> shader_light;
std::shared_ptr<NativeShader_Imp> shader_depth;
std::shared_ptr<NativeShader_Imp> shader_light_depth;
std::vector<asd::VertexLayout> vl;
vl.push_back(asd::VertexLayout("Position", asd::VertexLayoutFormat::R32G32B32_FLOAT));
vl.push_back(asd::VertexLayout("Normal", asd::VertexLayoutFormat::R32G32B32_FLOAT));
vl.push_back(asd::VertexLayout("Binormal", asd::VertexLayoutFormat::R32G32B32_FLOAT));
vl.push_back(asd::VertexLayout("UV", asd::VertexLayoutFormat::R32G32_FLOAT));
vl.push_back(asd::VertexLayout("UVSub", asd::VertexLayoutFormat::R32G32_FLOAT));
vl.push_back(asd::VertexLayout("Color", asd::VertexLayoutFormat::R8G8B8A8_UNORM));
vl.push_back(asd::VertexLayout("BoneWeights", asd::VertexLayoutFormat::R8G8B8A8_UNORM));
vl.push_back(asd::VertexLayout("BoneIndexes", asd::VertexLayoutFormat::R8G8B8A8_UINT));
vl.push_back(asd::VertexLayout("BoneIndexesOriginal", asd::VertexLayoutFormat::R8G8B8A8_UINT));
std::vector<asd::Macro> macro;
std::vector<asd::Macro> macro_light;
std::vector<asd::Macro> macro_depth;
std::vector<asd::Macro> macro_light_depth;
macro_depth.push_back(Macro("EXPORT_DEPTH", "1"));
macro_light_depth.push_back(Macro("EXPORT_DEPTH", "1"));
macro_light.push_back(Macro("LIGHTWEIGHT", "1"));
macro_light_depth.push_back(Macro("LIGHTWEIGHT", "1"));
if (g->GetGraphicsDeviceType() == GraphicsDeviceType::DirectX11)
{
shader = g->CreateShader_Imp(
model_internal_vs_dx,
"shader2d_dx_vs",
ToUtf8String(shaderText).c_str(),
ToUtf8String(shaderFileName).c_str(),
vl,
true,
macro);
shader_light = g->CreateShader_Imp(
lightweight_model_internal_vs_dx,
"shader2d_dx_vs",
ToUtf8String(shaderText).c_str(),
ToUtf8String(shaderFileName).c_str(),
vl,
true,
macro_light);
shader_depth = g->CreateShader_Imp(
model_internal_vs_dx,
"shader2d_dx_vs",
ToUtf8String(shaderText).c_str(),
ToUtf8String(shaderFileName).c_str(),
vl,
true,
macro_depth);
shader_light_depth = g->CreateShader_Imp(
lightweight_model_internal_vs_dx,
"shader2d_dx_vs",
ToUtf8String(shaderText).c_str(),
ToUtf8String(shaderFileName).c_str(),
vl,
true,
macro_light_depth);
}
else if (g->GetGraphicsDeviceType() == GraphicsDeviceType::OpenGL)
{
shader = g->CreateShader_Imp(
model_internal_vs_gl,
"shader3d_gl_vs",
ToUtf8String(shaderText).c_str(),
ToUtf8String(shaderFileName).c_str(),
vl,
true,
macro);
shader_light = g->CreateShader_Imp(
lightweight_model_internal_vs_gl,
"shader3d_gl_vs",
ToUtf8String(shaderText).c_str(),
ToUtf8String(shaderFileName).c_str(),
vl,
true,
macro_light);
shader_depth = g->CreateShader_Imp(
model_internal_vs_gl,
"shader3d_gl_vs",
ToUtf8String(shaderText).c_str(),
ToUtf8String(shaderFileName).c_str(),
vl,
true,
macro_depth);
shader_light_depth = g->CreateShader_Imp(
lightweight_model_internal_vs_gl,
"shader3d_gl_vs",
ToUtf8String(shaderText).c_str(),
ToUtf8String(shaderFileName).c_str(),
vl,
true,
macro_light_depth);
}
else
{
assert(0);
}
if (shader == nullptr) return nullptr;
return new Shader3D_Imp(
g,
shader,
shader_light,
shader_depth,
shader_light_depth,
shaderText,
shaderFileName);
}
const Macro& Driver::macro( const HashedString& name ) const {
std::pair< MacroMap::const_iterator, MacroMap::const_iterator > range = m_macros.equal_range( name );
if ( range.first == range.second ) {
return ( *const_cast<MacroMap&>( m_macros ).insert( std::make_pair( deepCopy( name.str() ), Macro() ) ) ).second; ///Since we need to return a reference, there's no other way.
} else {
return ( *( --range.second ) ).second;
}
}
SpriteRenderer3D::SpriteRenderer3D(Graphics* graphics)
: m_graphics(nullptr)
{
m_graphics = (Graphics_Imp*) graphics;
SafeAddRef(graphics);
m_vertexBuffer = m_graphics->CreateVertexBuffer_Imp(sizeof(SpriteVertex), SpriteCount * 4, true);
m_indexBuffer = m_graphics->CreateIndexBuffer_Imp(SpriteCount * 6, false, true);
{
m_indexBuffer->Lock();
auto ib = m_indexBuffer->GetBuffer<uint32_t>(SpriteCount * 6);
for (int32_t i = 0; i < SpriteCount; i++)
{
ib[i * 6 + 0] = 0 + i * 4;
ib[i * 6 + 1] = 1 + i * 4;
ib[i * 6 + 2] = 2 + i * 4;
ib[i * 6 + 3] = 0 + i * 4;
ib[i * 6 + 4] = 2 + i * 4;
ib[i * 6 + 5] = 3 + i * 4;
}
m_indexBuffer->Unlock();
}
std::vector<asd::VertexLayout> vl;
vl.push_back(asd::VertexLayout("Pos", asd::VertexLayoutFormat::R32G32B32_FLOAT));
vl.push_back(asd::VertexLayout("UV", asd::VertexLayoutFormat::R32G32_FLOAT));
vl.push_back(asd::VertexLayout("Color", asd::VertexLayoutFormat::R8G8B8A8_UNORM));
std::vector<asd::Macro> macro_tex;
macro_tex.push_back(Macro("HAS_TEXTURE", "1"));
std::vector<asd::Macro> macro;
if (m_graphics->GetGraphicsDeviceType() == GraphicsDeviceType::OpenGL)
{
m_shader = m_graphics->GetShaderCache()->CreateFromCode(
ToAString(L"Internal.3D.SpriteRenderer3D.Texture").c_str(),
sprite_renderer3d_vs_gl,
sprite_renderer3d_ps_gl,
vl,
macro_tex);
}
else
{
m_shader = m_graphics->GetShaderCache()->CreateFromCode(
ToAString(L"Internal.3D.SpriteRenderer3D.Texture").c_str(),
sprite_renderer3d_vs_dx,
sprite_renderer3d_ps_dx,
vl,
macro_tex);
}
if (m_graphics->GetGraphicsDeviceType() == GraphicsDeviceType::OpenGL)
{
m_shader_nt = m_graphics->GetShaderCache()->CreateFromCode(
ToAString(L"Internal.3D.SpriteRenderer3D").c_str(),
sprite_renderer3d_vs_gl,
sprite_renderer3d_ps_gl,
vl,
macro);
}
else
{
m_shader_nt = m_graphics->GetShaderCache()->CreateFromCode(
ToAString(L"Internal.3D.SpriteRenderer3D").c_str(),
sprite_renderer3d_vs_dx,
sprite_renderer3d_ps_dx,
vl,
macro);
}
}
