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); } }