int32_t PS3Graphics::LoadFragmentShader(std::string shaderPath) { // store the current path _curFragmentShaderPath = shaderPath; _vertexProgram = LoadShaderFromSource(_cgContext, CG_PROFILE_SCE_VP_RSX, shaderPath.c_str(), "main_vertex"); _fragmentProgram = LoadShaderFromSource(_cgContext, CG_PROFILE_SCE_FP_RSX, shaderPath.c_str(), "main_fragment"); // bind and enable the vertex and fragment programs cgGLEnableProfile(CG_PROFILE_SCE_VP_RSX); cgGLEnableProfile(CG_PROFILE_SCE_FP_RSX); cgGLBindProgram(_vertexProgram); cgGLBindProgram(_fragmentProgram); // acquire mvp param from vertex shader _cgpModelViewProj = cgGetNamedParameter(_vertexProgram, "modelViewProj"); _cgpVideoSize = cgGetNamedParameter(_fragmentProgram, "IN.video_size"); _cgpTextureSize = cgGetNamedParameter(_fragmentProgram, "IN.texture_size"); _cgpOutputSize = cgGetNamedParameter(_fragmentProgram, "IN.output_size"); if (active_shader) lib_free(active_shader); active_shader = util_concat(shaderPath.c_str(), NULL); return CELL_OK; }
void CG_RENDER_CUBEMAP(void) { glPushMatrix(); glTranslatef(0, 0.0f, 1.5f); //glRotatef(spinFloat -25, 0.0f, 0.0f, 1.0f); spinFloat += 0.0; glRotatef(90, 1.0, 0.0,0.0); cgGLBindProgram( cgVertexProgram ); cgGLBindProgram( cgFragmentProgram ); cgGLEnableProfile( cgVertexProfile ); cgGLEnableProfile( cgFragmentProfile ); cgGLEnableTextureParameter( cgEnvironmentMap ); cgGLSetStateMatrixParameter( cgModelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY ); cgGLSetStateMatrixParameter( cgModelView, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY ); cgGLSetStateMatrixParameter( cgModelViewI, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE ); cgGLSetStateMatrixParameter( cgModelViewIT, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE ); glInterleavedArrays( GL_T2F_N3F_V3F, 0, MeTooB); glDrawArrays( GL_TRIANGLES, 0, 7608); cgGLDisableTextureParameter( cgEnvironmentMap ); cgGLDisableProfile( cgVertexProfile ); cgGLDisableProfile( cgFragmentProfile ); glPopMatrix(); }
void Shader::Apply() { if (vertex_program) { cgGLSetStateMatrixParameter(cgGetNamedParameter(vertex_program, "ModelViewProj"), CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY); cgGLBindProgram(vertex_program); cgGLEnableProfile(vertex_profile); } else { cgGLDisableProfile(vertex_profile); } if (fragment_program) { GLint handle; CGparameter param; glGetIntegerv(GL_TEXTURE_BINDING_2D, &handle); param = cgGetNamedParameter(fragment_program, "Decal"); cgGLSetTextureParameter(param, handle); cgGLEnableTextureParameter(param); cgGLBindProgram(fragment_program); cgGLEnableProfile(fragment_profile); } else { cgGLDisableProfile(fragment_profile); } }
void COpenGLCgMaterialRenderer::OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial, bool resetAllRenderstates, IMaterialRendererServices* services) { Material = material; if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates) { if (VertexProgram) { cgGLEnableProfile(VertexProfile); cgGLBindProgram(VertexProgram); } if (FragmentProgram) { cgGLEnableProfile(FragmentProfile); cgGLBindProgram(FragmentProgram); } if (GeometryProgram) { cgGLEnableProfile(GeometryProfile); cgGLBindProgram(GeometryProgram); } if (BaseMaterial) BaseMaterial->OnSetMaterial(material, material, true, this); } if (CallBack) CallBack->OnSetMaterial(material); Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates); }
void DoBlur(unsigned int uiSrcTex, unsigned int uiTargetTex, int srcTexWidth, int srcTexHeight, int destTexWidth, int destTexHeight, float xofs, float yofs) { cgGLBindProgram(g_cgVP_GlowBlur); cgGLBindProgram(g_cgFP_GlowBlur); pglActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_RECTANGLE_NV); glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiSrcTex); pglActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_RECTANGLE_NV); glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiSrcTex); pglActiveTextureARB(GL_TEXTURE2_ARB); glEnable(GL_TEXTURE_RECTANGLE_NV); glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiSrcTex); pglActiveTextureARB(GL_TEXTURE3_ARB); glEnable(GL_TEXTURE_RECTANGLE_NV); glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiSrcTex); cgGLSetParameter1f(g_cgpVP1_XOffset, xofs); cgGLSetParameter1f(g_cgpVP1_YOffset, yofs); glViewport(0, 0, destTexWidth, destTexHeight); DrawQuad(srcTexWidth, srcTexHeight); glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiTargetTex); glCopyTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB, 0, 0, destTexWidth, destTexHeight, 0); }
void cgtk::raycasting_pass() { disable_renderbuffers(); //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_RECTANGLE_ARB,final_image,0); //glClearColor(0,0,0,0); //glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); cgGLEnableProfile(vertexProfile); cgGLEnableProfile(fragmentProfile); cgGLBindProgram(vertex_main); cgGLBindProgram(fragment_main); cgGLSetParameter1f(cgGetNamedParameter(fragment_main,"stepsize"),stepsize); cgGLSetParameter1f(cgGetNamedParameter(fragment_main,"width"),WINDOW_SIZE_W); cgGLSetParameter1f(cgGetNamedParameter(fragment_main,"heigth"),WINDOW_SIZE_H); set_tex_param("tex",backface_buffer,fragment_main,param1); set_tex_param("volume_tex",volume_texture,fragment_main,param2); glEnable(GL_BLEND); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); //drawQuads(1,1,1,b); drawBd(); cgGLDisableProfile(vertexProfile); cgGLDisableProfile(fragmentProfile); glDisable(GL_CULL_FACE); glDisable(GL_BLEND); }
static void gl_cg_use(unsigned index) { if (cg_active && prg[index].vprg && prg[index].fprg) { gl_cg_reset_attrib(); active_index = index; cgGLBindProgram(prg[index].vprg); cgGLBindProgram(prg[index].fprg); } }
static void gl_cg_use(void *data, void *shader_data, unsigned idx) { cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data; if (cg_data && cg_data->prg[idx].vprg && cg_data->prg[idx].fprg) { gl_cg_reset_attrib(cg_data); cg_data->active_idx = idx; cgGLBindProgram(cg_data->prg[idx].vprg); cgGLBindProgram(cg_data->prg[idx].fprg); } }
static void gl_cg_use(void *data, unsigned idx) { cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data; (void)data; if (cg && cg->prg[idx].vprg && cg->prg[idx].fprg) { gl_cg_reset_attrib(cg); cg->active_idx = idx; cgGLBindProgram(cg->prg[idx].vprg); cgGLBindProgram(cg->prg[idx].fprg); } }
void FreezeParticle::Render(float x, float y, float z, float theta, float thetaX, float thetaY, float thetaZ) { glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); cgGLEnableProfile(FreezeParticleProfile); cgGLBindProgram(FreezeParticleProgram); cgGLEnableTextureParameter(FreezeParticleText1); glPushMatrix(); glTranslatef(x,y,z); glTranslatef(mPos.GetX(), mPos.GetY(), mPos.GetZ()); glRotatef(mRotate, 0.2f, 0.5f, 1); glRotatef(theta, thetaX, thetaY, thetaZ); glScalef((30-mLife)/30,(30-mLife)/30,(30-mLife)/30); glBegin(GL_TRIANGLES); glTexCoord3f(0,0,0); glVertex3f(-3,0,0); glTexCoord3f(.5,1,0); glVertex3f(0, 3, 0); glTexCoord3f(0,0,0); glVertex3f(1, 0, 0); glEnd(); glPopMatrix(); cgGLDisableProfile(FreezeParticleProfile); }
void board_update() { cgGLEnableProfile(cg__fragmentProfile); cgGLBindProgram(cg__fragmentProgram); // transfer data to texture texture_load_array(board__computeTexture, GL_TEXTURE_RECTANGLE_ARB, board__width, board__width, board__data); // perform computation CGparameter textureCg = cgGetNamedParameter(cg__fragmentProgram, "aBoard"); cgGLSetTextureParameter(textureCg, board__computeTexture); cgGLEnableTextureParameter(textureCg); CGparameter widthCg = cgGetNamedParameter(cg__fragmentProgram, "aWidth"); cgSetParameter1f(widthCg, board__width); board_draw(); // GPGPU CONCEPT 4: Viewport-Sized Quad = Data Stream Generator. cgGLDisableTextureParameter(textureCg); cgGLDisableProfile(cg__fragmentProfile); // Read back the results glReadBuffer(GL_COLOR_ATTACHMENT0_EXT); // The glReadBuffer function selects a color buffer source for pixels. // void glReadBuffer(GLenum mode); mode is a color buffer // The glReadPixels function reads a block of pixels from the framebuffer. glReadPixels( 0, 0, // GLint x, y The window coordinates of the first pixel that is read from the framebuffer. This location is the lower-left corner of a rectangular block of pixels board__width, // GLsizei width board__width, // GLsizei height GL_RGBA, // GLenum format GL_FLOAT, // GLenum type board__data); // GLvoid *pixels }
//--------------------------------------------------------------------------------- // bind vertex/fragment program // PSGL specific //--------------------------------------------------------------------------------- void FFxProgram::bind() { if (!mProgram) return; #ifdef WIN32 if (GDD->GetClassID() == ClassIDZDisplayDeviceDX9) { HRESULT hr = cgD3D9BindProgram(mProgram); /* if (mProfile == CG_PROFILE_VS_2_0) { HRESULT hr = GDD->GetD3D9Device()->SetVertexShader((IDirect3DVertexShader9*)mDXShader->GetBufferPointer()); int a = 1; } else { GDD->GetD3D9Device()->SetPixelShader((IDirect3DPixelShader9*)mDXShader->GetBufferPointer()); } */ } else #endif { cgGLEnableProfile(mProfile); cgGLBindProgram(mProgram); } }
void newScenes(int sc1, int sc2) { sprintf(fileName, "cg_%d_%d.txt", sc1, sc2); fileName[10] = '\0'; if((pts = fopen(fileName, "r")) == NULL){ printf("Couldn't open file: %s\n", fileName); exit(EXIT_FAILURE); } char *ln; size_t sz; posLen = 0; while((ln = fgetln(pts, &sz)) != NULL) { fillPoint(&(posList[posLen]), ln); posLen++; } fclose(pts); sprintf(progName, "cg_%d_%d.cg", sc1, sc2); cgGLUnbindProgram(f_prof); cgGLEnableProfile(f_prof); gen = cgCreateProgramFromFile(context, CG_SOURCE, progName, f_prof, "main", NULL); cgGLLoadProgram(gen); cgGLBindProgram(gen); cgGLEnableProfile(f_prof); }
static void fshader_select (int select_in) { FShader* s; Env* e; fshader_selected = select_in - FSHADER_BASE; if (fshader_selected == -1 || !CVarUtils::GetCVar<bool> ("render.textured")) { cgGLDisableProfile (cgp_fragment); return; } if (!CVarUtils::GetCVar<bool> ("render.shaders")) return; s = &fshader_list[fshader_selected]; e = EnvGet (); cgGLEnableProfile (cgp_fragment); cgGLBindProgram (s->program); if (select_in == FSHADER_CLOUDS) { GLrgba c = (e->color[ENV_COLOR_SKY] + e->color[ENV_COLOR_HORIZON]) / 2.0f; cgGLSetParameter3f (s->fogcolor, c.red, c.green, c.blue); } else cgGLSetParameter3f (s->fogcolor, e->color[ENV_COLOR_FOG].red, e->color[ENV_COLOR_FOG].green, e->color[ENV_COLOR_FOG].blue); cgGLSetTextureParameter (s->texture, TextureIdFromName ("clouds.png")); cgGLSetParameter4f (s->data, wind, e->cloud_cover, 1 - e->star_fade, 0); cgGLEnableTextureParameter (s->texture); }
void ShaderCG::preRender(Renderer* renderer) { #ifdef HAS_CG if (!use_cg) return; cgGLEnableProfile(profile_vertex); cgGLEnableProfile(profile_fragment); cgGLBindProgram(program_vertex); cgGLBindProgram(program_fragment); if(g_modelViewProjMatrix != NULL) cgGLSetStateMatrixParameter(g_modelViewProjMatrix, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY); if(g_modelViewMatrix != NULL) cgGLSetStateMatrixParameter(g_modelViewMatrix, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY); if(g_modelViewMatrixI != NULL) cgGLSetStateMatrixParameter(g_modelViewMatrixI, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE); if(g_modelViewMatrixIT != NULL) cgGLSetStateMatrixParameter(g_modelViewMatrixIT, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE); Light light; renderer->getLight(&light, 0); if(g_lightDiffuse != NULL) cgGLSetParameter4fv(g_lightDiffuse, light.getDiffuse()); if(g_lightPosition != NULL) cgGLSetParameter4fv(g_lightPosition, light.getPos()); /* if(g_lightAmbiente != NULL) cgGLSetParameter4fv(g_lightAmbiente, light.getAmbiente()); if(g_lightSpecular != NULL) cgGLSetParameter4fv(g_lightSpecular, light.getSpecular()); */ ErrorCheck(); glDisable(GL_LIGHTING); #endif // HAS_CG }
void cgShader_3::Enable(){ for(int k = 0; k < 5; k++){ if(cgProgram[k]){ cgGLEnableProfile(cgProfile[k]); cgGLBindProgram(cgProgram[k]); } } }
void CgShaderProgramGL::bind() { if (!ParameterMap_.empty()) cgUpdateProgramParameters(cgProgram_); cgGLBindProgram(cgProgram_); cgGLEnableProfile(cgProfile_); }
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; }
void Cg::BindProgram(CGprogram program){ if(program != NULL) cgGLBindProgram(program); else { cout<<"CGparameter is null"<<endl; abort(); } CheckCgError(); }
int32_t FceuGraphics::LoadFragmentShader(string shaderPath) { LOG_DBG("LoadFragmentShader(%s)\n", shaderPath.c_str()); // store the cur path _curFragmentShaderPath = shaderPath; _vertexProgram = LoadShaderFromSource(_cgContext, CG_PROFILE_SCE_VP_RSX, shaderPath.c_str(), "main_vertex"); if (_vertexProgram <= 0) { LOG_DBG("Error loading vertex shader..."); return 1; } _fragmentProgram = LoadShaderFromSource(_cgContext, CG_PROFILE_SCE_FP_RSX, shaderPath.c_str(), "main_fragment"); if (_fragmentProgram <= 0) { LOG_DBG("Error loading fragment shader..."); return 1; } // bind and enable the vertex and fragment programs cgGLEnableProfile(CG_PROFILE_SCE_VP_RSX); cgGLEnableProfile(CG_PROFILE_SCE_FP_RSX); cgGLBindProgram(_vertexProgram); cgGLBindProgram(_fragmentProgram); // acquire mvp param from v shader _cgpModelViewProj = cgGetNamedParameter(_vertexProgram, "modelViewProj"); if (CheckCgError (__LINE__) != CG_NO_ERROR) { // FIXME: WHY DOES THIS GIVE ERROR ON OTHER LOADS //return 1; } _cgpVideoSize = cgGetNamedParameter(_fragmentProgram, "IN.video_size"); _cgpTextureSize = cgGetNamedParameter(_fragmentProgram, "IN.texture_size"); _cgpOutputSize = cgGetNamedParameter(_fragmentProgram, "IN.output_size"); LOG_DBG("SUCCESS - LoadFragmentShader(%s)\n", shaderPath.c_str()); return CELL_OK; }
void ParticleShaderDiskDevelop::drawParticle(int i) { cgGLEnableProfile(vProfile); cgGLEnableProfile(fProfile); cgGLBindProgram(vProgram); bindCGParametersVertex(); bindCGParametersFragment(); cgGLBindProgram(fProgram); GLfloat lightpos[4]; glGetLightfv(GL_LIGHT0, GL_POSITION, lightpos); cgGLSetParameter4fv(lightPositionEC, lightpos); // Pull the diffuse color GLfloat diff[4]; glGetMaterialfv(GL_FRONT, GL_DIFFUSE, diff); // Set the disk center GLfloat dC[3] = {0.0, 0.0, 0.0}; // Get the radius if (radius_data) radius = (*radius_data)[i]; else radius = 1.0; // Set the per-particle Cg parameters cgGLSetParameter3fv(diskCenterWC, dC); cgGLSetParameter4fv(diffuseColor, diff); cgGLSetParameter1f(diskRadius, GLfloat(radius * scale)); cgGLSetStateMatrixParameter(modelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY); cgGLSetStateMatrixParameter(modelView, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY); cgGLSetStateMatrixParameter(modelViewIT, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE); gluDisk(quad,0,radius*scale*1.51,4,4); cgGLDisableProfile(vProfile); cgGLDisableProfile(fProfile); }
void ObjMeshGPUDeformer::RenderEdges() { glDisable(GL_TEXTURE_2D); cgGLEnableProfile(VertexProfile); cgGLBindProgram(VertexPass2ProgramEdges); cgGLSetStateMatrixParameter(ModelViewProjEdgeParam, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY); cgGLSetStateMatrixParameter(ModelViewITEdgeParam, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE); glBindTexture(GL_TEXTURE_2D, vertexDeformationTextureID); BindRT(); #ifdef OBJMESHGPUDEFORMER_USING_VBOS glEnableClientState(GL_VERTEX_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); glEnableClientState(GL_TEXTURE_COORD_ARRAY); for(int groupNo=0; groupNo<numGroups; groupNo++) { // render via VBOs glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboEdgesID[3*groupNo+0]); glVertexPointer(3, GL_FLOAT, 0, 0); glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboEdgesID[3*groupNo+1]); glTexCoordPointer(2, GL_FLOAT, 0, 0); glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, vboEdgesID[3*groupNo+2]); int numGroupEdges = 3 * numGroupTriangles[groupNo]; glDrawElements(GL_LINES, 2 * numGroupEdges, GL_UNSIGNED_INT, 0); } // unbind VBOs glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); #else for(int groupNo=0; groupNo<numGroups; groupNo++) glCallList(displayListEdgesStart + groupNo); #endif UnbindRT(); cgGLDisableProfile(VertexProfile); }
void DrawSea() { seatime=seatime+1.0f/2400.0f; if(seatime>1.0f) seatime=seatime-1.0f; cgSetParameter1f(cgGetNamedParameter( g_Sea_vertex, "time"), seatime); g_CGparam_AmbientReflectiveSea = cgGetNamedParameter(g_Sea_pixel, "AmbientReflectiveTexturSea"); cgGLSetTextureParameter( g_CGparam_AmbientReflectiveSea, AmbientReflectiveTexture ); cgSetParameter3fv(cgGetNamedParameter( g_Sea_pixel, "globalAmbient" ), globalAmbient); cgSetParameter3fv(cgGetNamedParameter( g_Sea_pixel, "paraLightColor" ), paraLightColor); cgSetParameter3fv(cgGetNamedParameter( g_Sea_pixel, "paraLightDirection" ), LightSunPos); cgSetParameter3fv(cgGetNamedParameter( g_Sea_pixel, "eyePosition"), eyePositionSea); cgSetParameter3fv(cgGetNamedParameter( g_Sea_pixel, "FogColor"), pixelfogColor); //cgSetParameter1f(cgGetNamedParameter( g_Sea_pixel, "time"), seatime); cgGLBindProgram( g_Sea_vertex ); cgGLEnableProfile( g_CGprofile_vertex ); cgGLBindProgram( g_Sea_pixel ); cgGLEnableProfile( g_CGprofile_pixel ); cgGLEnableTextureParameter( g_CGparam_AmbientReflectiveSea ); }
void COpenGLCgMaterialRenderer::OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial, bool resetAllRenderstates, IMaterialRendererServices* services) { if (Driver->getFixedPipelineState() == COpenGLDriver::EOFPS_ENABLE) Driver->setFixedPipelineState(COpenGLDriver::EOFPS_ENABLE_TO_DISABLE); else Driver->setFixedPipelineState(COpenGLDriver::EOFPS_DISABLE); if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates) { if (VertexProgram) { cgGLEnableProfile(VertexProfile); cgGLBindProgram(VertexProgram); } if (FragmentProgram) { cgGLEnableProfile(FragmentProfile); cgGLBindProgram(FragmentProgram); } if (GeometryProgram) { cgGLEnableProfile(GeometryProfile); cgGLBindProgram(GeometryProgram); } } Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates); if (BaseMaterial) BaseMaterial->OnSetBaseMaterial(material); if (CallBack) CallBack->OnSetMaterial(material); Material = material; }
bool GLCgShader::SetShader() { cgGLBindProgram(m_cgProgam); if (CheckForError("cgGLBindProgram", m_shaderName)) return false; cgUpdateProgramParameters(m_cgProgam); if (CheckForError("cgUpdateProgramParameters", m_shaderName)) return false; cgGLEnableProfile(m_cgProfile); if (CheckForError("cgGLEnableProfile", m_shaderName)) return false; return true; }
void display(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); cgGLBindProgram(cg_vertex_program); checkForCgError("binding vertex program"); cgGLEnableProfile(cg_vertex_profile); checkForCgError("enabling vertex profile"); // parameter //cgGLSetParameter1f(cg_parameter_vertex_scale_factor, 0.7); //cgGLSetParameter1f(cg_parameter_vertex_rotation, rotation); // Zeit die seit dem rendern des letzten Bildes vergangen ist: cgGLEnableTextureParameter(cg_parameter_vertex_time); t = diff_seconds(); glVertex2f(0.0f, 0.0f); glTexCoord1f(Particle->t); cgGLDisableTextureParameter(cg_parameter_vertex_time); // Berechnung der Framerate mit Hilfe der Zeitmessungsfunktion: frames++; timer += t; if (timer > 1.0) { printf("Frames per second: %i\n", frames); timer -= 1.0; frames = 0; printf("Number of particles: %d\n", water_list.size()); } //cgGLEnableTextureParameter(cg_parameter_vertex_velocity); drawParticles(water_list,water_tex); //glVertex2f(0.0f, 0.0f); //glTexCoord3fv(Particle->velocity); //cgGLDisableTextureParameter(cg_parameter_vertex_velocity); cgGLDisableProfile(cg_vertex_profile); checkForCgError("disabling vertex profile"); glutSwapBuffers(); }
void CgStartDrawCallback::operator()( osg::RenderInfo& renderInfo ) const { if ( !_initialized ) { for ( unsigned int i=0; i<_programs.size(); ++i ) { cgGLLoadProgram( _programs[i] ); } _initialized = true; } for ( unsigned int i=0; i<_programs.size(); ++i ) { cgGLBindProgram( _programs[i] ); } for ( unsigned int i=0; i<_profiles.size(); ++i ) { cgGLEnableProfile( _profiles[i] ); } }
void ObjMeshGPUDeformer::RenderVertices() { glDisable(GL_TEXTURE_2D); cgGLEnableProfile(VertexProfile); cgGLBindProgram(VertexPass2ProgramPoints); cgGLSetStateMatrixParameter(ModelViewProjPointParam, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY); cgGLSetStateMatrixParameter(ModelViewITPointParam, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE); glBindTexture(GL_TEXTURE_2D, vertexDeformationTextureID); BindRT(); glCallList(displayListPoints); UnbindRT(); cgGLDisableProfile(VertexProfile); }
// // Set // void CCgShadingProgram::Set() const { cgGLBindProgram( m_Program ); #ifdef _DEBUG CGerror Error = cgGetError(); if (Error != CG_NO_ERROR) throw CCgException( this, Error, "::Set() : A Cg error has occured." ); #endif if (!m_FeedbackAttribs.empty()) { #ifdef _DEBUG glClearErrors(); #endif glTransformFeedbackAttribsNV( static_cast<GLsizei>( m_FeedbackAttribs.size() / 3 ), &m_FeedbackAttribs[ 0 ], m_FeedbackMode ); #ifdef _DEBUG GLenum Error = glGetError(); if (Error != GL_NO_ERROR) throw CException( this, Error, "::Set() : An OpenGL error has occured." ); #endif } }
static void vshader_select (int select) { VShader* s; GLvector p; Env* e; GLrgba c; float val1, val2; vshader_selected = select; if (!CVarUtils::GetCVar<bool> ("render.shaders")) return; if (select == VSHADER_NONE) { cgGLDisableProfile (cgp_vertex); return; } val1 = val2 = 0.0f; if (select == VSHADER_TREES || select == VSHADER_GRASS) val1 = wind; if (select == VSHADER_CLOUDS) val1 = wind / 5; s = &vshader_list[select]; e = EnvGet (); cgGLEnableProfile (cgp_vertex); cgGLBindProgram (s->program); cgGLSetParameter3f (s->lightpos, -e->light.x, -e->light.y, -e->light.z); c = e->color[ENV_COLOR_LIGHT]; cgGLSetParameter3f (s->lightcol, c.red, c.green, c.blue); c = e->color[ENV_COLOR_AMBIENT] * glRgba (0.2f, 0.2f, 1.0f); cgGLSetParameter3f (s->ambientcol, c.red, c.green, c.blue); p = AvatarCameraPosition (); cgGLSetParameter3f (s->eyepos, p.x, p.y, p.z); cgGLSetStateMatrixParameter(s->matrix, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MODELVIEW_MATRIX); cgGLSetParameter2f (s->fog, e->fog.rmin, e->fog.rmax); cgGLSetParameter4f (s->data, SceneVisibleRange (), SceneVisibleRange () * 0.05, val1, val2); glColor3f (1,1,1); }