bool ZZshStartUsingShaders() { cgSetErrorHandler(HandleCgError, NULL); g_cgcontext = cgCreateContext(); cgvProf = CG_PROFILE_ARBVP1; cgfProf = CG_PROFILE_ARBFP1; cgGLEnableProfile(cgvProf); cgGLEnableProfile(cgfProf); cgGLSetOptimalOptions(cgvProf); cgGLSetOptimalOptions(cgfProf); cgGLSetManageTextureParameters(g_cgcontext, CG_FALSE); //cgSetAutoCompile(g_cgcontext, CG_COMPILE_IMMEDIATE); g_fparamFogColor = cgCreateParameter(g_cgcontext, CG_FLOAT4); g_vparamPosXY[0] = cgCreateParameter(g_cgcontext, CG_FLOAT4); g_vparamPosXY[1] = cgCreateParameter(g_cgcontext, CG_FLOAT4); ZZLog::GS_Log("Creating effects."); B_G(LoadEffects(), return false); // create a sample shader clampInfo temp; memset(&temp, 0, sizeof(temp)); temp.wms = 3; temp.wmt = 3; g_nPixelShaderVer = 0;//SHADER_ACCURATE; // test bool bFailed; FRAGMENTSHADER* pfrag = ZZshLoadShadeEffect(0, 1, 1, 1, 1, temp, 0, &bFailed); if( bFailed || pfrag == NULL ) { g_nPixelShaderVer = SHADER_ACCURATE|SHADER_REDUCED; pfrag = ZZshLoadShadeEffect(0, 0, 1, 1, 0, temp, 0, &bFailed); if( pfrag != NULL ) cgGLLoadProgram(pfrag->prog); if( bFailed || pfrag == NULL || cgGetError() != CG_NO_ERROR ) { g_nPixelShaderVer = SHADER_REDUCED; ZZLog::Error_Log("Basic shader test failed."); } } if (g_nPixelShaderVer & SHADER_REDUCED) conf.bilinear = 0; ZZLog::GS_Log("Creating extra effects."); B_G(ZZshLoadExtraEffects(), return false); ZZLog::GS_Log("using %s shaders\n", g_pShaders[g_nPixelShaderVer]); return true; }
void Effect::initialize() { context = cgCreateContext(); if (context == 0) { throw std::runtime_error("Could not create context"); } cgSetErrorHandler(CgErrorHandler, 0); cgGLRegisterStates(context); cgGLSetManageTextureParameters(context, true); }
void _initCgRuntime(ID3D11Device *dev) { if(gCgContext == nullptr) { std::cout << "[CgRuntime] Initialize Cg-Runtime-Direct3D 11" << std::endl; //qDebug("[Cg] Initialize Cg"); // register the error handler cgSetErrorHandler( &_cgErrorHandler, NULL); // create a new Cg Context gCgContext = cgCreateContext(); HRESULT hr = cgD3D11SetDevice( gCgContext, dev); if( hr != S_OK ) return; // Register the default state assignment for OpenGL //cgD3D11RegisterStates(gCgContext); // This will allow the Cg runtime to manage texture binding //cgD3D11SetManageTextureParameters(gCgContext, CG_TRUE); gCgVertexShaderProfile = cgD3D11GetLatestVertexProfile(); if(gCgVertexShaderProfile == CG_PROFILE_UNKNOWN) { // ERROR std::cout << "[CgRuntime] Error: Could not get valid Vertex-Profile." << std::endl; return; } gCgGeometryShaderProfile = cgD3D11GetLatestGeometryProfile(); if(gCgGeometryShaderProfile == CG_PROFILE_UNKNOWN) { // WARNING std::cout << "[CgRuntime] Warning: Could not get valid Geometry-Profile." << std::endl; } gCgFragmentShaderProfile = cgD3D11GetLatestPixelProfile(); if(gCgFragmentShaderProfile == CG_PROFILE_UNKNOWN) { // ERROR std::cout << "[CgRuntime] Error: Could not get valid Fragment-Profile." << std::endl; return; } profileOpts = cgD3D11GetOptimalOptions(gCgVertexShaderProfile); } }
static void *gl_cg_init(void *data, const char *path) { unsigned i; cg_shader_data_t *cg_data = (cg_shader_data_t*) calloc(1, sizeof(cg_shader_data_t)); if (!cg_data) return NULL; #ifdef HAVE_CG_RUNTIME_COMPILER cgRTCgcInit(); #endif cg_data->cgCtx = cgCreateContext(); if (!cg_data->cgCtx) { RARCH_ERR("Failed to create Cg context.\n"); goto error; } #ifdef RARCH_CG_DEBUG cgGLSetDebugMode(CG_TRUE); cgSetErrorHandler(cg_error_handler, NULL); #endif cg_data->cgFProf = cgGLGetLatestProfile(CG_GL_FRAGMENT); cg_data->cgVProf = cgGLGetLatestProfile(CG_GL_VERTEX); if ( cg_data->cgFProf == CG_PROFILE_UNKNOWN || cg_data->cgVProf == CG_PROFILE_UNKNOWN) { RARCH_ERR("Invalid profile type\n"); free(cg_data); cg_data = NULL; goto error; } RARCH_LOG("[Cg]: Vertex profile: %s\n", cgGetProfileString(cg_data->cgVProf)); RARCH_LOG("[Cg]: Fragment profile: %s\n", cgGetProfileString(cg_data->cgFProf)); cgGLSetOptimalOptions(cg_data->cgFProf); cgGLSetOptimalOptions(cg_data->cgVProf); cgGLEnableProfile(cg_data->cgFProf); cgGLEnableProfile(cg_data->cgVProf); memset(cg_data->cg_alias_define, 0, sizeof(cg_data->cg_alias_define)); if (path && string_is_equal(path_get_extension(path), "cgp")) { if (!gl_cg_load_preset(cg_data, path)) goto error; } else { if (!gl_cg_load_plain(cg_data, path)) goto error; } cg_data->prg[0].mvp = cgGetNamedParameter(cg_data->prg[0].vprg, "IN.mvp_matrix"); for (i = 1; i <= cg_data->shader->passes; i++) gl_cg_set_program_attributes(cg_data, i); /* If we aren't using last pass non-FBO shader, * this shader will be assumed to be "fixed-function". * * Just use prg[0] for that pass, which will be * pass-through. */ cg_data->prg[cg_data->shader->passes + 1] = cg_data->prg[0]; /* No need to apply Android hack in Cg. */ cg_data->prg[GL_SHADER_STOCK_BLEND] = cg_data->prg[0]; cgGLBindProgram(cg_data->prg[1].fprg); cgGLBindProgram(cg_data->prg[1].vprg); return cg_data; error: gl_cg_destroy_resources(cg_data); if (!cg_data) free(cg_data); return NULL; }
static bool gl_cg_init(const char *path) { unsigned i; #ifdef HAVE_CG_RUNTIME_COMPILER cgRTCgcInit(); #endif if (!cgCtx) cgCtx = cgCreateContext(); if (cgCtx == NULL) { RARCH_ERR("Failed to create Cg context\n"); return false; } #ifdef RARCH_CG_DEBUG cgGLSetDebugMode(CG_TRUE); cgSetErrorHandler(cg_error_handler, NULL); #endif cgFProf = cgGLGetLatestProfile(CG_GL_FRAGMENT); cgVProf = cgGLGetLatestProfile(CG_GL_VERTEX); if (cgFProf == CG_PROFILE_UNKNOWN || cgVProf == CG_PROFILE_UNKNOWN) { RARCH_ERR("Invalid profile type\n"); goto error; } #ifndef HAVE_RGL RARCH_LOG("[Cg]: Vertex profile: %s\n", cgGetProfileString(cgVProf)); RARCH_LOG("[Cg]: Fragment profile: %s\n", cgGetProfileString(cgFProf)); #endif cgGLSetOptimalOptions(cgFProf); cgGLSetOptimalOptions(cgVProf); cgGLEnableProfile(cgFProf); cgGLEnableProfile(cgVProf); if (path && strcmp(path_get_extension(path), "cgp") == 0) { if (!load_preset(path)) goto error; } else { if (!load_plain(path)) goto error; } prg[0].mvp = cgGetNamedParameter(prg[0].vprg, "IN.mvp_matrix"); for (i = 1; i <= cg_shader->passes; i++) set_program_attributes(i); // If we aren't using last pass non-FBO shader, // this shader will be assumed to be "fixed-function". // Just use prg[0] for that pass, which will be // pass-through. prg[cg_shader->passes + 1] = prg[0]; // No need to apply Android hack in Cg. prg[GL_SHADER_STOCK_BLEND] = prg[0]; cgGLBindProgram(prg[1].fprg); cgGLBindProgram(prg[1].vprg); cg_active = true; return true; error: gl_cg_deinit(); return false; }
void DXWindow::initPipeline() { HRESULT hr; #ifdef USE_CG // INIT CG { std::cout << "Initialize Cg-Runtime-Direct3D 11" << std::endl; //qDebug("[Cg] Initialize Cg"); // register the error handler cgSetErrorHandler(&_cgErrorHandler, NULL); // create a new Cg Context mCgContext = cgCreateContext(); HRESULT hr = cgD3D11SetDevice(mCgContext, mDevice); if (hr != S_OK) return; // Register the default state assignment for OpenGL cgD3D11RegisterStates(mCgContext); // This will allow the Cg runtime to manage texture binding cgD3D11SetManageTextureParameters(mCgContext, CG_TRUE); } // LOAD SHADER Cg { std::string sourcePtr = read("vshader.cg"); int num = sizeof(CG_VERTEX_SHADER_PROFILES) / sizeof(CG_VERTEX_SHADER_PROFILES[0]); for (int i = 0; i < num; ++i) { auto optimal = cgD3D11GetOptimalOptions(CG_VERTEX_SHADER_PROFILES[i]); mVertexShaderId = cgCreateProgram(mCgContext, CG_SOURCE, sourcePtr.c_str(), CG_VERTEX_SHADER_PROFILES[i], "main", optimal); hr = cgD3D11LoadProgram(mVertexShaderId, NULL); if (SUCCEEDED(hr)) break; } if (SUCCEEDED(hr)) { std::cout << "Loaded vertex shader!\n"; } else { std::cout << "Could not load vertex shader!\n"; exit(-1); } sourcePtr = read("fshader.cg"); num = sizeof(CG_PIXEL_SHADER_PROFILES) / sizeof(CG_PIXEL_SHADER_PROFILES[0]); for (int i = 0; i < num; ++i) { auto optimal = cgD3D11GetOptimalOptions(CG_PIXEL_SHADER_PROFILES[i]); mFragmentShaderId = cgCreateProgram(mCgContext, CG_SOURCE, sourcePtr.c_str(), CG_PIXEL_SHADER_PROFILES[i], "main", optimal); hr = cgD3D11LoadProgram(mFragmentShaderId, NULL); if (SUCCEEDED(hr)) break; } if (SUCCEEDED(hr)) { std::cout << "Loaded pixel shader!\n"; } else { std::cout << "Could not load pixel shader!\n"; exit(-1); } // get a D3D shader resource from CG shader resource ID3D10Blob* VS = cgD3D11GetCompiledProgram(mVertexShaderId); // activate the shader objects cgD3D11BindProgram(mVertexShaderId); cgD3D11BindProgram(mFragmentShaderId); // create the input layout object D3D11_INPUT_ELEMENT_DESC ied[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }, }; hr = mDevice->CreateInputLayout(ied, 2, VS->GetBufferPointer(), VS->GetBufferSize(), &mLayout); if (SUCCEEDED(hr)) { std::cout << "Created vertex layout for shader!\n"; } else { std::cout << "Could not create vertex layout for shader!\n"; exit(-1); } mDeviceContext->IASetInputLayout(mLayout); } // Load Shader HLSL #else { //Compile Shaders from shader file hr = D3DX11CompileFromFile("shaders.shader", 0, 0, "VS", "vs_4_0", 0, 0, 0, &VS_Buffer, 0, 0); hr = D3DX11CompileFromFile("shaders.shader", 0, 0, "PS", "ps_4_0", 0, 0, 0, &PS_Buffer, 0, 0); //Create the Shader Objects hr = mDevice->CreateVertexShader(VS_Buffer->GetBufferPointer(), VS_Buffer->GetBufferSize(), NULL, &VS); hr = mDevice->CreatePixelShader(PS_Buffer->GetBufferPointer(), PS_Buffer->GetBufferSize(), NULL, &PS); //Set Vertex and Pixel Shaders mDeviceContext->VSSetShader(VS, 0, 0); mDeviceContext->PSSetShader(PS, 0, 0); // create the input layout object D3D11_INPUT_ELEMENT_DESC ied[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }, }; hr = mDevice->CreateInputLayout(ied, 2, VS_Buffer->GetBufferPointer(), VS_Buffer->GetBufferSize(), &mLayout); if (SUCCEEDED(hr)) { std::cout << "Created vertex layout for shader!\n"; } else { std::cout << "Could not create vertex layout for shader!\n"; exit(-1); } mDeviceContext->IASetInputLayout(mLayout); } #endif }