static bool d3d_init_shader(void *data) { d3d_video_t *d3d = (d3d_video_t*)data; (void)d3d; (void)data; #if defined(HAVE_HLSL) RARCH_LOG("D3D]: Using HLSL shader backend.\n"); const shader_backend_t *backend = &hlsl_backend; const char *shader_path = g_settings.video.shader_path; d3d->shader = backend; if (!d3d->shader) return false; return d3d->shader->init(d3d, shader_path); #elif defined(HAVE_CG) d3d->cgCtx = cgCreateContext(); if (!d3d->cgCtx) return false; RARCH_LOG("[D3D]: Created shader context.\n"); HRESULT ret = cgD3D9SetDevice(d3d->dev); if (FAILED(ret)) return false; return true; #elif defined(_XBOX1) return false; #endif }
void ParticleShaderDiskDevelop::setupCG() { if (cgGLIsProfileSupported(CG_PROFILE_VP30)) vProfile = CG_PROFILE_VP30; else exit(-1); if (cgGLIsProfileSupported(CG_PROFILE_FP30)) fProfile = CG_PROFILE_FP30; else exit(-1); // Create the Cg context CGcontext cgContext = cgCreateContext(); // Create the vertex program vProgram = cgCreateProgramFromFile(cgContext, CG_SOURCE, "../Particles/vertex.cg", vProfile, NULL, NULL); cgGLLoadProgram(vProgram); // Create the fragment programs fProgram = cgCreateProgramFromFile(cgContext, CG_SOURCE, "../Particles/clip_frag_d.cg", fProfile, NULL, NULL); cgGLLoadProgram(fProgram); }
ShaderSystem::ShaderSystem() { cgContext=cgCreateContext(); checkError("creating context"); cgGLSetDebugMode(CG_FALSE); cgSetParameterSettingMode(cgContext,CG_DEFERRED_PARAMETER_SETTING); //profiles vertexProfile=cgGLGetLatestProfile(CG_GL_VERTEX); cgGLSetOptimalOptions(vertexProfile); checkError("selecting vertex profile"); fragmentProfile=cgGLGetLatestProfile(CG_GL_FRAGMENT); cgGLSetOptimalOptions(fragmentProfile); checkError("selecting fragment profile"); printf("vertex profile: %s\n", cgGetProfileString(cgGLGetLatestProfile(CG_GL_VERTEX))); printf("geometry profile: %s\n", cgGetProfileString(cgGLGetLatestProfile(CG_GL_GEOMETRY))); printf("fragment profile: %s\n", cgGetProfileString(cgGLGetLatestProfile(CG_GL_FRAGMENT))); }
INT WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) { g_cgContext = cgCreateContext(); checkForCgError("creating context"); cgSetParameterSettingMode(g_cgContext, CG_DEFERRED_PARAMETER_SETTING); DXUTSetCallbackDeviceReset(OnResetDevice); DXUTSetCallbackDeviceLost(OnLostDevice); DXUTSetCallbackFrameRender(OnFrameRender); /* Parse command line, handle default hotkeys, and show messages. */ DXUTInit(); DXUTCreateWindow(g_strWindowTitleW); /* Display 400x400 window. */ DXUTCreateDevice(D3DADAPTER_DEFAULT, true, 400, 400); DXUTMainLoop(); cgDestroyProgram(g_cgVertexProgram); checkForCgError("destroying vertex program"); cgDestroyContext(g_cgContext); return DXUTGetExitCode(); }
//----------------------------------------------------------------------- CgProgramFactory::CgProgramFactory() { mCgContext = cgCreateContext(); // Check for errors checkForCgError("CgProgramFactory::CgProgramFactory", "Unable to create initial Cg context: ", mCgContext); }
/** * @fn Initialize() * @brief Setup the simulation. */ void Initialize() { // Initialize the UI InitParameters(); // First initialize extensions. int err = glewInit(); if (GLEW_OK != err) { /* problem: glewInit failed, something is seriously wrong */ fprintf(stderr, "Error: %s\n", glewGetErrorString(err)); exit(-1); } // Create the Cg context cgSetErrorCallback(cgErrorCallback); // Create cgContext. g_cgContext = cgCreateContext(); // Create and initialize the Flo simulator object g_pFlo = new Flo(g_iFloWidth, g_iFloHeight); g_pFlo->Initialize(g_cgContext); glDisable(GL_DEPTH_TEST); glDisable(GL_LIGHTING); }
CgDxEffect::CgDxEffect(D3D11GraphicDevice* device): mContext(0), mDevice(device) { mContext = cgCreateContext(); mist_assert(mContext); cgD3D11SetDevice(mContext, device->getD3DDevice()); }
CShaderLoader::CShaderLoader(TShaderType type) : ILoader (), m_type (type), m_shader (nullptr) { // Création du context m_context = cgCreateContext(); }
/*------------------------------------------------------------------------- -------------------------------------------------------------------------*/ bool FilterBox::Initialize(int w, int h) { bufw = w; bufh = h; // // FBO // glGenFramebuffersEXT(2, fb); glGenTextures(2, textureID); glGenRenderbuffersEXT(1, &depth_rb); initRT(0, w, h); initRT(1, w, h); // // initialize depth renderbuffer // glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, w, h); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb); CheckFramebufferStatus(); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // // CGFX things // cgContext = cgCreateContext(); cgGLRegisterStates(cgContext); std::string resolved_path; cgEffect = cgCreateEffectFromFile(cgContext, "data/shaders/FilterBox.cgfx", NULL); if(!cgEffect) { exit(0); const char * pszErrors = NULL; fprintf(stderr, "CgFx Parse error : %s", pszErrors); const char *listing = cgGetLastListing(cgContext); bValid = false; return false; } cgTechnique = cgGetNamedTechnique(cgEffect, "Filter"); cgPassFilterH = cgGetNamedPass(cgTechnique, "verticalPass"); cgPassFilterV = cgGetNamedPass(cgTechnique, "horizontalPass"); cgPassBlend = cgGetNamedPass(cgTechnique, "drawFinal"); cgBlendFactor = cgGetNamedEffectParameter(cgEffect, "blendFactor"); cgGlowFactor = cgGetNamedEffectParameter(cgEffect, "glowFactor"); srcSampler = cgGetNamedEffectParameter(cgEffect, "srcSampler"); tempSampler = cgGetNamedEffectParameter(cgEffect, "tempSampler"); finalSampler = cgGetNamedEffectParameter(cgEffect, "finalSampler"); verticalDir = cgGetNamedEffectParameter(cgEffect, "verticalDir"); horizontalDir = cgGetNamedEffectParameter(cgEffect, "horizontalDir"); cgGLSetParameter2f(verticalDir, 0,1.0f/(float)h); cgGLSetParameter2f(horizontalDir, 1.0f/(float)w, 0); bValid = true; return true; }
void CGlutCgWindow::initializeCg() { // Basic Cg setup; register a callback function for any errors // and create an initial context cgSetErrorCallback(handleCgError); s_CgContext = cgCreateContext(); }
CgDxEffect::CgDxEffect(D3D11GraphicDevice* device): mContext(0), mDevice(device) { mContext = cgCreateContext(); mist_assert(mContext); cgD3D11SetDevice(mContext, device->getD3DDevice()); cgD3D11SetManageTextureParameters(mContext, CG_TRUE); }
int main( int argc, char **argv ) { glutInit( &argc, argv ); glutInitWindowSize(1000, 1000); glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE); glutCreateWindow("Fractal Shader"); glutDisplayFunc(display); glutReshapeFunc(reshape); glutMotionFunc(mouseMove); glutMouseFunc(mouseAction); glutIdleFunc(OnIdle); glutKeyboardFunc(keyAction); glutKeyboardUpFunc(keyUp); glClearColor(0, 0, 0, 1); CGcontext context = cgCreateContext(); if(context == NULL){ printf("Failed to create CGcontext\n"); return 1; } f_prof = cgGLGetLatestProfile(CG_GL_FRAGMENT); v_prof = cgGLGetLatestProfile(CG_GL_VERTEX); printf("%d, %d\n", f_prof, v_prof); chdir("/Users/peter/Desktop/CG/cgtest"); julia = cgCreateProgramFromFile(context, CG_SOURCE, "Julia.cg", f_prof, "main", NULL); newton = cgCreateProgramFromFile(context, CG_SOURCE, "Newton.cg", f_prof, "main", NULL); mandel = cgCreateProgramFromFile(context, CG_SOURCE, "Mandel.cg", f_prof, "main", NULL); ship = cgCreateProgramFromFile(context, CG_SOURCE, "Ship.cg", f_prof, "main", NULL); pass = cgCreateProgramFromFile(context, CG_SOURCE, "Pass.cg", v_prof, "main", NULL); gen = cgCreateProgramFromFile(context, CG_SOURCE, "GenIter.cg", f_prof, "main", NULL); printf("%s\n", cgGetErrorString(cgGetError())); cgGLLoadProgram(julia); cgGLLoadProgram(newton); cgGLLoadProgram(mandel); cgGLLoadProgram(ship); cgGLLoadProgram(gen); cgGLLoadProgram(pass); //printf("%s\n", cgGetErrorString(cgGetError())); cgGLEnableProfile(f_prof); cgGLEnableProfile(v_prof); printf("%s\n", cgGetErrorString(cgGetError())); Position demoList[7]; fillPoint(&demoList[0], 0.297205, 0.063085, 0.001157, 1.012991, 15.0, 7); fillPoint(&demoList[1], 0.134370, 0.042840, 0.043976, 1.008928, 15.0, 7); fillPoint(&demoList[2], -0.129831, -0.637758, 0.507148, 1.103996, 15.0, 7); fillPoint(&demoList[3], -0.162030, -1.02009, 0.041826, 0.983991, 15.0, 7); fillPoint(&demoList[4], -0.139263, -1.846086, 0.002345, 0.516934, 15.0, 7); fillPoint(&demoList[5], -0.138215, -1.910406, 0.001638, 0.495934, 15.0, 7); fillPoint(&demoList[6], -0.138215, -3.552904, 0.302149, 0.149937, 15.0, 7); posList = demoList; zoom = 0.001157; glutMainLoop(); return 0; }
GPUProgram::GPUProgram(void) { cgSetErrorCallback(handleCgError); context = cgCreateContext(); if (!cgIsContext(context)){ fprintf(stderr, "Cg Error: cannot create context!\n"); exit(1); } _chooseProfiles(); }
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; }
//##ModelId=4C32C6EF0290 fluid::glExtension::btGLShaderModel_4_0::btGLShaderModel_4_0(const char* name) { context=cgCreateContext(); hasVertex= hasGeometry= hasFragment=false; isBind=false; this->name=(char*)malloc(strlen(name)+1); memcpy(this->name,name,strlen(name)+1); }
void init( unsigned int _width, unsigned int _height ) { window_width = _width; window_height = _height; glfwInit(); glfwOpenWindowHint( GLFW_FSAA_SAMPLES, 8 ); glfwOpenWindow( window_width, window_height, 8, 8, 8, 8, 16, 0, GLFW_WINDOW ); glfwSetWindowSizeCallback( &resizeEvent ); std::cout << glGetString( GL_VERSION ) << std::endl; glfwSwapInterval( 1 ); GLenum err = glewInit(); if (GLEW_OK != err) { std::cout << "Error: " << glewGetErrorString(err) << std::endl; throw -1; } // ilInit(); // iluInit(); chdir( BOOST_PP_STRINGIZE( RESOURCE_DIRECTORY ) ); cgSetErrorCallback(&checkCgError); context = cgCreateContext(); cgGLRegisterStates( context ); quit_flag = false; cam_position[ 0 ] = 0.0f; cam_position[ 1 ] = 3.5f; cam_position[ 2 ] = 7.0f; cam_velocity[ 0 ] = 0.0f; cam_velocity[ 1 ] = 0.0f; cam_velocity[ 2 ] = 0.0f; cam_velocity[ 3 ] = 0.0f; cam_direction[ 0 ] = 0.0f; cam_direction[ 1 ] = 0.0f; cam_direction[ 2 ] = -1.0f; light_position = 0.0; light_velocity = 0.0; obj_position[ 0 ] = 0.0f; obj_position[ 1 ] = 0.0f; obj_velocity[ 0 ] = 0.0f; obj_velocity[ 1 ] = 0.0f; cam_moving_x = 0; cam_moving_y = 0; cam_moving_z = 0; cam_moving_dir = 0; lit_moving_x = 0; obj_moving_x = 0; obj_moving_y = 0; glfwSetKeyCallback( &keycb ); }
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 InitCG() { if( cgGLIsProfileSupported(CG_PROFILE_ARBVP1) ) g_CGprofile_vertex = CG_PROFILE_ARBVP1; else if( cgGLIsProfileSupported(CG_PROFILE_VP40) ) g_CGprofile_vertex = CG_PROFILE_VP40; else { ShaderWater=false; return; } if( cgGLIsProfileSupported(CG_PROFILE_ARBFP1) ) g_CGprofile_pixel = CG_PROFILE_ARBFP1; else if( cgGLIsProfileSupported(CG_PROFILE_FP30) ) g_CGprofile_pixel = CG_PROFILE_FP30; else if( cgGLIsProfileSupported(CG_PROFILE_FP20) ) g_CGprofile_pixel = CG_PROFILE_FP20; else { ShaderWater=false; return; } g_CGcontext = cgCreateContext(); g_Sea_vertex = cgCreateProgramFromFile( g_CGcontext, CG_SOURCE, "Sea_vertex.cg", g_CGprofile_vertex, NULL, NULL ); cgGLLoadProgram(g_Sea_vertex); CGerror GetCGerror=cgGetError(); if(GetCGerror!=CG_NO_ERROR) MessageBox (HWND_DESKTOP, "vertex shader Error!", "Error", MB_OK | MB_ICONEXCLAMATION); g_Sea_pixel = cgCreateProgramFromFile( g_CGcontext, CG_SOURCE, "Sea_pixel.cg", g_CGprofile_pixel, NULL, NULL ); cgGLLoadProgram(g_Sea_pixel); GetCGerror=cgGetError(); if(GetCGerror!=CG_NO_ERROR) MessageBox (HWND_DESKTOP, "pixel shader Error!", "Error", MB_OK | MB_ICONEXCLAMATION); }
void CgInit(){ CgCtxt = cgCreateContext(); CgProg = cgCreateProgramFromFile( CgCtxt, CG_SOURCE, "shader.cg", CgProf, NULL, NULL ); if( CgProg != NULL ){ cgGLLoadProgram( CgProg ); ModelViewProjParam = cgGetNamedParameter( CgProg, "ModelViewProj" ); LightAngle = cgGetNamedParameter( CgProg, "LA" ); LightY = cgGetNamedParameter( CgProg, "LY" ); } }
int32_t PS3Graphics::InitCg() { cgRTCgcInit(); _cgContext = cgCreateContext(); if (_cgContext == NULL) return 1; if (strlen(_curFragmentShaderPath.c_str()) > 0) return LoadFragmentShader(_curFragmentShaderPath.c_str()); else { _curFragmentShaderPath = DEFAULT_SHADER_FILE; return LoadFragmentShader(_curFragmentShaderPath.c_str()); } }
bool d3d_init_shader(void *data) { D3DVideo *d3d = reinterpret_cast<D3DVideo*>(data); d3d->cgCtx = cgCreateContext(); if (d3d->cgCtx == NULL) return false; RARCH_LOG("[D3D9 Cg]: Created context.\n"); HRESULT ret = cgD3D9SetDevice(d3d->dev); if (FAILED(ret)) return false; return true; }
i32 CCGShaderSystem::Init(IRenderSystem* pRS) { UnloadLibraries(); if( XST_FAILED( LoadLibraries() ) ) { return XST_FAIL; } m_pRS = pRS; m_CGContext = cgCreateContext(); CHECK_CG_ERR( "creating context", "" ); return XST_OK; }
int _tmain(int argc, char ** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE); glutInitWindowSize(500, 500); glutCreateWindow("render_texture_3D"); glutDisplayFunc(display); glutKeyboardFunc(key); glutMotionFunc(myMotion); glutPassiveMotionFunc(myPMotion); glutIdleFunc(idle); context = cgCreateContext(); cgSetErrorCallback(cgErrorCallback); fluid=new Fluid3D(context,64,64,64,0.0025f,1,0.5); glutMainLoop(); }
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); } }
int main(int argc,char** argv) { diff_seconds(); srand(time(NULL)); glutInit(&argc, argv); glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE |GLUT_RGB); glutInitWindowSize (900,600); glutInitWindowPosition (240, 40); glutCreateWindow ("E16 - Partikelsystem"); glutKeyboardFunc(keyboard); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_COLOR_MATERIAL); init(); glutDisplayFunc(display); glutIdleFunc(idle); glEnable(GL_DEPTH_TEST); /********************************************/ cg_context = cgCreateContext(); checkForCgError("creating context"); cg_vertex_profile = cgGLGetLatestProfile(CG_GL_VERTEX); cgGLSetOptimalOptions(cg_vertex_profile); checkForCgError("selecting vertex profile"); cg_vertex_program = cgCreateProgramFromFile(cg_context, CG_SOURCE, "vertex.cg", cg_vertex_profile, "more_complex_vertex_shader", NULL); checkForCgError("creating vertex program from file"); cgGLLoadProgram(cg_vertex_program); checkForCgError("loading vertex program"); /**************************************************/ cg_parameter_vertex_velocity = cgGetNamedParameter(cg_vertex_program, "Texture0"); cg_parameter_vertex_time = cgGetNamedParameter(cg_vertex_program, "Texture1"); glutMainLoop(); return 0; }
static bool d3d9_cg_renderchain_init_shader(d3d9_video_t *d3d, cg_renderchain_t *renderchain) { CGcontext cgCtx = cgCreateContext(); if (!cgCtx) { RARCH_ERR("Failed to create Cg context.\n"); return false; } if (FAILED(cgD3D9SetDevice((IDirect3DDevice9*)d3d->dev))) return false; renderchain->cgCtx = cgCtx; return true; }
int main(int argc, char **argv) { glutInitWindowSize(600, 600); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); glutInit(&argc, argv); glutCreateWindow("Per vertex lighting (Gouraud shading)"); glutDisplayFunc(display); glutKeyboardFunc(keyboard); glutReshapeFunc(reshape); glClearColor(0.0, 0.0, 0.0, 1.0); cg_context = cgCreateContext(); checkForCgError("creating context"); cg_vertex_profile = cgGLGetLatestProfile(CG_GL_VERTEX); cgGLSetOptimalOptions(cg_vertex_profile); checkForCgError("selecting vertex profile"); cg_vertex_program = cgCreateProgramFromFile(cg_context, CG_SOURCE, "E12_vertex.cg", cg_vertex_profile, "per_vertex_lighting", NULL); checkForCgError("creating vertex program from file"); cgGLLoadProgram(cg_vertex_program); checkForCgError("loading vertex program"); GET_PARAM(modelview_proj); GET_PARAM(translation); GET_PARAM(ambient_light); GET_PARAM(light_color); GET_PARAM(light_position); GET_PARAM(camera_position); GET_PARAM(Ke); GET_PARAM(Ka); GET_PARAM(Kd); GET_PARAM(Ks); GET_PARAM(exponent); glEnable(GL_DEPTH_TEST); glutMainLoop(); return 0; }
bool ShaderCG::init(const char* file_v, const char* file_f) { #ifdef HAS_CG CGcontext context = cgCreateContext(); profile_vertex = cgGLGetLatestProfile(CG_GL_VERTEX);; profile_fragment = cgGLGetLatestProfile(CG_GL_FRAGMENT);; cgGLSetOptimalOptions(profile_vertex); cgGLSetOptimalOptions(profile_fragment); program_vertex = cgCreateProgramFromFile(context, CG_SOURCE, file_v, profile_vertex , 0, 0); program_fragment = cgCreateProgramFromFile(context, CG_SOURCE, file_f, profile_fragment, 0, 0); if (!program_vertex || !program_fragment) { ErrorCheck(); use_cg = false; printf("Shaders Disabled\n"); return false; } g_modelViewProjMatrix = cgGetNamedParameter(program_vertex, "ModelViewProj"); g_modelViewMatrix = cgGetNamedParameter(program_vertex, "ModelView"); g_modelViewMatrixI = cgGetNamedParameter(program_vertex, "ModelViewI"); g_modelViewMatrixIT = cgGetNamedParameter(program_vertex, "ModelViewIT"); g_lightPosition = cgGetNamedParameter(program_vertex, "LightPos"); g_lightDiffuse = cgGetNamedParameter(program_fragment, "lightcolor"); //g_lightAmbiente = cgGetNamedParameter(program_vertex, "LightAmbiente"); //g_lightSpecular = cgGetNamedParameter(program_vertex, "LightSpecular"); cgGLLoadProgram(program_vertex); cgGLLoadProgram(program_fragment); ErrorCheck(); printf("Shaders Enabled\n"); return true; #else printf("Shaders Disabled\n"); return false; #endif // HAS_CG }
GLCgShaderContext::GLCgShaderContext() : m_cgContext(0) { m_cgContext = cgCreateContext(); CheckForError("GLCgShaderContext creating the context"); cgSetParameterSettingMode(m_cgContext, CG_DEFERRED_PARAMETER_SETTING); CheckForError("GLCgShaderContext setting parameter mode"); #ifdef DEBUG cgGLSetDebugMode(CG_TRUE); #else cgGLSetDebugMode(CG_FALSE); #endif m_latestFragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT); m_latestVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX); }
int createShader ( int n, std::string vname, std::string vfunc, std::string fname, std::string ffunc) { #if 0 char vnbuf[200]; char vfbuf[200]; char fnbuf[200]; char ffbuf[200]; strcpy ( vnbuf, vname.c_str() ); strcpy ( vfbuf, vfunc.c_str() ); strcpy ( fnbuf, fname.c_str() ); strcpy ( ffbuf, ffunc.c_str() ); if ( cgContext == 0 ) { cgSetErrorCallback( cgErrorCallback ); cgContext = cgCreateContext(); } // Select profiles vert_profile = cgGLGetLatestProfile ( CG_GL_VERTEX ); cgGLSetOptimalOptions( vert_profile ); frag_profile = cgGLGetLatestProfile ( CG_GL_FRAGMENT ); cgGLSetOptimalOptions( frag_profile ); printf ( "Vertex profile: %s\n", cgGetProfileString(vert_profile) ); printf ( "Fragment profile: %s\n", cgGetProfileString(frag_profile) ); printf ( " (See http.developer.nvidia.com/Cg/index_profiles.html)\n"); //debug.PrintF ( "rend", "Geometry profile: %s\n", cgGetProfileString(vert_profile) ); printf ( "Loading VP: %s\n", vnbuf ); cgVP = cgCreateProgramFromFile( cgContext, CG_SOURCE, vnbuf, vert_profile, vfbuf, NULL ); cgGLLoadProgram( cgVP ); printf ( "Loading FP: %s\n", fnbuf ); cgFP = cgCreateProgramFromFile( cgContext, CG_SOURCE, fnbuf, frag_profile, ffbuf, NULL ); cgGLLoadProgram( cgFP ); cgGLSetManageTextureParameters ( cgContext, CG_FALSE ); cgGLBindProgram ( cgVP ); cgGLBindProgram ( cgFP ); #endif return 0; }