BEGIN_SHADER_PARAMS END_SHADER_PARAMS // Set up anything that is necessary to make decisions in SHADER_FALLBACK. SHADER_INIT_PARAMS() { if ( g_pHardwareConfig->SupportsBorderColor() ) { params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight_border" ); } else { params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight001" ); } // No texture means no self-illum or env mask in base alpha if ( !params[BASETEXTURE]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } SET_FLAGS( MATERIAL_VAR_DECAL ); SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); SET_FLAGS2( MATERIAL_VAR2_LIGHTING_LIGHTMAP ); }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); if( !params[ENVMAPMASKSCALE]->IsDefined() ) params[ENVMAPMASKSCALE]->SetFloatValue( 1.0f ); if( !params[ENVMAPTINT]->IsDefined() ) params[ENVMAPTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); if( !params[SELFILLUMTINT]->IsDefined() ) params[SELFILLUMTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); if( !params[DETAILSCALE]->IsDefined() ) params[DETAILSCALE]->SetFloatValue( 4.0f ); // No envmap uses mode 0, it's one less pass // Also, if multipass = 0, then go to mode 0 also if ( ( !params[ENVMAP]->IsDefined() ) || ( !IS_FLAG_SET(MATERIAL_VAR_MULTIPASS) ) ) { CLEAR_FLAGS( MATERIAL_VAR_ENVMAPMODE ); } // Vertex color requires mode 1 if ( IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR) ) { SET_FLAGS( MATERIAL_VAR_ENVMAPMODE ); } // No texture means no self-illum or env mask in base alpha if ( !params[BASETEXTURE]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } // If in decal mode, no debug override... if ( IS_FLAG_SET(MATERIAL_VAR_DECAL) ) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } SET_FLAGS2( MATERIAL_VAR2_LIGHTING_VERTEX_LIT ); SET_FLAGS2( MATERIAL_VAR2_NEEDS_SOFTWARE_LIGHTING ); // Get rid of the envmap if it's optional for this dx level. if( params[ENVMAPOPTIONAL]->IsDefined() && params[ENVMAPOPTIONAL]->GetIntValue() ) { params[ENVMAP]->SetUndefined(); } // If mat_specular 0, then get rid of envmap if( !g_pConfig->UseSpecular() && params[ENVMAP]->IsDefined() && params[BASETEXTURE]->IsDefined() ) { params[ENVMAP]->SetUndefined(); } }
void InitParamsLightShafts( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, LightShaftsVars_t &info ) { // Set material flags SET_FLAGS( MATERIAL_VAR_TRANSLUCENT ); SET_FLAGS( MATERIAL_VAR_NOCULL ); SET_PARAM_INT_IF_NOT_DEFINED( info.m_nCookieFrameNum, 0 ); SET_PARAM_FLOAT_IF_NOT_DEFINED( info.m_nTime, 0.0f ); }
SHADER_INIT_PARAMS() { VertexLitGeneric_DX9_Vars_t vars; vars.m_nDisplacementMap = DISPLACEMENTMAP; vars.m_nDisplacementWrinkleMap = DISPLACEMENTWRINKLE; InitParamsVertexLitGeneric_DX9( this, params, pMaterialName, false, vars ); SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); SET_FLAGS( MATERIAL_VAR_NOFOG ); SET_FLAGS( MATERIAL_VAR_WIREFRAME ); }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { // FIXME: This can share code with sprite.cpp // FIXME: Not sure if this is the best solution, but it's a very] // easy one. When graphics aren't enabled, we oftentimes need to get // at the parameters of a shader. Therefore, we must set the default // values in a separate phase from when we load resources. if (!params[ALPHA]->IsDefined()) params[ ALPHA ]->SetFloatValue( 1.0f ); SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); SET_FLAGS( MATERIAL_VAR_VERTEXCOLOR ); SET_FLAGS( MATERIAL_VAR_VERTEXALPHA ); // translate from a string orientation to an enumeration if (params[SPRITEORIENTATION]->IsDefined()) { const char *orientationString = params[SPRITEORIENTATION]->GetStringValue(); if( stricmp( orientationString, "parallel_upright" ) == 0 ) { params[SPRITEORIENTATION]->SetIntValue( SPR_VP_PARALLEL_UPRIGHT ); } else if( stricmp( orientationString, "facing_upright" ) == 0 ) { params[SPRITEORIENTATION]->SetIntValue( SPR_FACING_UPRIGHT ); } else if( stricmp( orientationString, "vp_parallel" ) == 0 ) { params[SPRITEORIENTATION]->SetIntValue( SPR_VP_PARALLEL ); } else if( stricmp( orientationString, "oriented" ) == 0 ) { params[SPRITEORIENTATION]->SetIntValue( SPR_ORIENTED ); } else if( stricmp( orientationString, "vp_parallel_oriented" ) == 0 ) { params[SPRITEORIENTATION]->SetIntValue( SPR_VP_PARALLEL_ORIENTED ); } else { Warning( "error with $spriteOrientation\n" ); params[SPRITEORIENTATION]->SetIntValue( SPR_VP_PARALLEL_UPRIGHT ); } } else { // default case params[SPRITEORIENTATION]->SetIntValue( SPR_VP_PARALLEL_UPRIGHT ); } }
/** * Get the flags associated with a format string * @param format The format string to search. * @param flags A pointer to flags that are turned on. * @return A pointer to the format string */ const char *_get_flags(const char *format, uchar *flags) { uchar f; uchar done = 0; // start with no flags CLEAR_FLAGS(f, PRINTF_ALL); // skip past the % char ++format; while(!done) { char ch = *format++; switch(ch) { case '-': // justify, overrides padding SET_FLAGS(f, PRINTF_JUSTIFY); CLEAR_FLAGS(f, PRINTF_PADDING); break; case '+': // sign, overrides space SET_FLAGS(f, PRINTF_SIGN); CLEAR_FLAGS(f, PRINTF_SPACE); break; case ' ': if(!GET_FLAG(f, PRINTF_SIGN)) { SET_FLAGS(f, PRINTF_SPACE); } break; case '#': SET_FLAGS(f, PRINTF_PREFIX); break; case '0': if(!GET_FLAG(f, PRINTF_JUSTIFY)) { SET_FLAGS(f, PRINTF_PADDING); } break; default: done = 1; --format; } } *flags = f; return format; }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); }
END_SHADER_PARAMS /* SHADER_FALLBACK { if( g_pHardwareConfig->GetDXSupportLevel() < 90 ) { return "sky_dx6"; } return 0; } */ SHADER_INIT_PARAMS() { SET_FLAGS( MATERIAL_VAR_NOFOG ); SET_FLAGS( MATERIAL_VAR_IGNOREZ ); }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { SET_FLAGS2( MATERIAL_VAR2_LIGHTING_LIGHTMAP ); if( !params[ENVMAPMASKSCALE]->IsDefined() ) params[ENVMAPMASKSCALE]->SetFloatValue( 1.0f ); if( !params[DETAILSCALE]->IsDefined() ) params[DETAILSCALE]->SetFloatValue( 1.0f ); if( !params[ENVMAPTINT]->IsDefined() ) params[ENVMAPTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); // No texture means no self-illum or env mask in base alpha if ( !params[BASETEXTURE]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } // If in decal mode, no debug override... if (IS_FLAG_SET(MATERIAL_VAR_DECAL)) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); SET_FLAGS( MATERIAL_VAR_TRANSLUCENT ); if( !params[ENVMAPTINT]->IsDefined() ) { params[ENVMAPTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); } if( !params[ENVMAPCONTRAST]->IsDefined() ) { params[ENVMAPCONTRAST]->SetFloatValue( 0.0f ); } if( !params[ENVMAPSATURATION]->IsDefined() ) { params[ENVMAPSATURATION]->SetFloatValue( 1.0f ); } if( !params[ENVMAPFRAME]->IsDefined() ) { params[ENVMAPFRAME]->SetIntValue( 0 ); } if( !params[BASETEXTURE]->IsDefined() ) { SET_FLAGS2( MATERIAL_VAR2_NEEDS_POWER_OF_TWO_FRAME_BUFFER_TEXTURE ); } }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { if( !params[ENVMAPTINT]->IsDefined() ) params[ENVMAPTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); if( !params[ENVMAPMASKSCALE]->IsDefined() ) params[ENVMAPMASKSCALE]->SetFloatValue( 1.0f ); if( !params[DETAILSCALE]->IsDefined() ) params[DETAILSCALE]->SetFloatValue( 4.0f ); // No texture means no env mask in base alpha if ( !params[BASETEXTURE]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } // If in decal mode, no debug override... if (IS_FLAG_SET(MATERIAL_VAR_DECAL)) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } // Get rid of the envmap if it's optional for this dx level. if( params[ENVMAPOPTIONAL]->IsDefined() && params[ENVMAPOPTIONAL]->GetIntValue() ) { params[ENVMAP]->SetUndefined(); } // If mat_specular 0, then get rid of envmap if( !g_pConfig->UseSpecular() && params[ENVMAP]->IsDefined() && params[BASETEXTURE]->IsDefined() ) { params[ENVMAP]->SetUndefined(); } }
//----------------------------------------------------------------------------- // Initialize shader parameters //----------------------------------------------------------------------------- void InitParamsPhong_DX9( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, VertexLitGeneric_DX9_Vars_t &info ) { // FLASHLIGHTFIXME: Do ShaderAPI::BindFlashlightTexture Assert( info.m_nFlashlightTexture >= 0 ); params[FLASHLIGHTTEXTURE]->SetStringValue( GetFlashlightTextureFilename() ); // Write over $basetexture with $info.m_nBumpmap if we are going to be using diffuse normal mapping. if( info.m_nAlbedo != -1 && g_pConfig->UseBumpmapping() && info.m_nBumpmap != -1 && params[info.m_nBumpmap]->IsDefined() && params[info.m_nAlbedo]->IsDefined() && params[info.m_nBaseTexture]->IsDefined() ) { params[info.m_nBaseTexture]->SetStringValue( params[info.m_nAlbedo]->GetStringValue() ); } // This shader can be used with hw skinning SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); SET_FLAGS2( MATERIAL_VAR2_LIGHTING_VERTEX_LIT ); // No texture means no env mask in base alpha if ( !params[info.m_nBaseTexture]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } // If in decal mode, no debug override... if (IS_FLAG_SET(MATERIAL_VAR_DECAL)) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } // We always specify we're using user data, therefore we always need tangent spaces SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); bool bBump = (info.m_nBumpmap != -1) && g_pConfig->UseBumpmapping() && params[info.m_nBumpmap]->IsDefined(); bool bEnvMap = (info.m_nEnvmap != -1) && params[info.m_nEnvmap]->IsDefined(); bool bDiffuseWarp = (info.m_nDiffuseWarpTexture != -1) && params[info.m_nDiffuseWarpTexture]->IsDefined(); bool bPhong = (info.m_nPhong != -1) && params[info.m_nPhong]->IsDefined(); if( !bBump && !bEnvMap && !bDiffuseWarp && !bPhong ) { CLEAR_FLAGS( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ); } if ( ( info.m_nSelfIllumFresnelMinMaxExp != -1 ) && ( !params[info.m_nSelfIllumFresnelMinMaxExp]->IsDefined() ) ) { params[info.m_nSelfIllumFresnelMinMaxExp]->SetVecValue( 0.0f, 1.0f, 1.0f ); } InitFloatParam( info.m_nEnvmapFresnel, params, 0.0f ); InitFloatParam( info.m_nAmbientOcclusion, params, 0.0f ); InitFloatParam( info.m_nDisplacementWrinkleMap, params, 0.0f ); InitIntParam( info.m_nSelfIllumFresnel, params, 0 ); InitIntParam( info.m_nBaseMapAlphaPhongMask, params, 0 ); InitIntParam( info.m_nBaseMapLuminancePhongMask, params, 0 ); InitIntParam( info.m_nShaderSrgbRead360, params, 0 ); InitIntParam( info.m_nAllowDiffuseModulation, params, 1 ); InitIntParam( info.m_nPhongDisableHalfLambert, params, 0 ); SET_PARAM_STRING_IF_NOT_DEFINED( info.m_nFoW, "_rt_fog_of_war" ); }
LOCAL VOID flag_obj(LONG tree, WORD which, WORD bit) { WORD flags; flags = GET_FLAGS(tree, which); SET_FLAGS(tree, which, flags | bit); }
BEGIN_SHADER_PARAMS END_SHADER_PARAMS SHADER_INIT_PARAMS() { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); }
BEGIN_SHADER_PARAMS END_SHADER_PARAMS SHADER_INIT_PARAMS() { SET_FLAGS( MATERIAL_VAR_TRANSLUCENT ); }
void InitParamsCloakBlendedPass( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, CloakBlendedPassVars_t &info ) { // Set material flags SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); SET_FLAGS( MATERIAL_VAR_MODEL ); SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); // Set material parameter default values if ( ( info.m_nCloakFactor != -1 ) && ( !params[info.m_nCloakFactor]->IsDefined() ) ) { params[info.m_nCloakFactor]->SetFloatValue( kDefaultCloakFactor ); } if ( ( info.m_nRefractAmount != -1 ) && ( !params[info.m_nRefractAmount]->IsDefined() ) ) { params[info.m_nRefractAmount]->SetFloatValue( kDefaultRefractAmount ); } if ( ( info.m_nCloakColorTint != -1 ) && ( !params[info.m_nCloakColorTint]->IsDefined() ) ) { params[info.m_nCloakColorTint]->SetVecValue( kDefaultCloakColorTint[0], kDefaultCloakColorTint[1], kDefaultCloakColorTint[2], kDefaultCloakColorTint[3] ); } if( (info.m_nBumpFrame != -1 ) && !params[info.m_nBumpFrame]->IsDefined() ) { params[info.m_nBumpFrame]->SetIntValue( 0 ); } }
END_SHADER_PARAMS // FIXME: doesn't support fresnel! SHADER_INIT_PARAMS() { SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); SET_FLAGS( MATERIAL_VAR_TRANSLUCENT ); if( !params[ENVMAPTINT]->IsDefined() ) { params[ENVMAPTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); } if( !params[ENVMAPCONTRAST]->IsDefined() ) { params[ENVMAPCONTRAST]->SetFloatValue( 0.0f ); } if( !params[ENVMAPSATURATION]->IsDefined() ) { params[ENVMAPSATURATION]->SetFloatValue( 1.0f ); } if( !params[ENVMAPFRAME]->IsDefined() ) { params[ENVMAPFRAME]->SetIntValue( 0 ); } if( !params[FRESNELREFLECTION]->IsDefined() ) { params[FRESNELREFLECTION]->SetFloatValue( 1.0f ); } }
// FIXME: doesn't support fresnel! void InitParamsRefract_DX9( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, Refract_DX9_Vars_t &info ) { SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); SET_FLAGS( MATERIAL_VAR_TRANSLUCENT ); if( !params[info.m_nEnvmapTint]->IsDefined() ) { params[info.m_nEnvmapTint]->SetVecValue( 1.0f, 1.0f, 1.0f ); } if( !params[info.m_nEnvmapContrast]->IsDefined() ) { params[info.m_nEnvmapContrast]->SetFloatValue( 0.0f ); } if( !params[info.m_nEnvmapSaturation]->IsDefined() ) { params[info.m_nEnvmapSaturation]->SetFloatValue( 1.0f ); } if( !params[info.m_nEnvmapFrame]->IsDefined() ) { params[info.m_nEnvmapFrame]->SetIntValue( 0 ); } if( !params[info.m_nFresnelReflection]->IsDefined() ) { params[info.m_nFresnelReflection]->SetFloatValue( 1.0f ); } if( !params[info.m_nMasked]->IsDefined() ) { params[info.m_nMasked]->SetIntValue( 0 ); } if( !params[info.m_nBlurAmount]->IsDefined() ) { params[info.m_nBlurAmount]->SetIntValue( 0 ); } if( !params[info.m_nFadeOutOnSilhouette]->IsDefined() ) { params[info.m_nFadeOutOnSilhouette]->SetIntValue( 0 ); } if( !params[info.m_nNoViewportFixup]->IsDefined() ) { params[info.m_nNoViewportFixup]->SetIntValue( 0 ); } if( !params[info.m_nMirrorAboutViewportEdges]->IsDefined() ) { params[info.m_nMirrorAboutViewportEdges]->SetIntValue( 0 ); } if ( !params[info.m_nMagnifyEnable]->IsDefined() ) { params[info.m_nMagnifyEnable]->SetIntValue( 0 ); } if ( !params[info.m_nMagnifyCenter]->IsDefined() ) { params[info.m_nMagnifyCenter]->SetVecValue( 0, 0, 0, 0 ); } if ( !params[info.m_nMagnifyScale]->IsDefined() ) { params[info.m_nMagnifyScale]->SetIntValue( 0 ); } SET_FLAGS2( MATERIAL_VAR2_NEEDS_POWER_OF_TWO_FRAME_BUFFER_TEXTURE ); }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { // default to 'MODEL' mode... if (!IS_FLAG_DEFINED( MATERIAL_VAR_MODEL )) SET_FLAGS( MATERIAL_VAR_MODEL ); }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); SET_FLAGS( MATERIAL_VAR_TRANSLUCENT ); SET_FLAGS2( MATERIAL_VAR2_NEEDS_POWER_OF_TWO_FRAME_BUFFER_TEXTURE ); }
char load(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity, char immediate_load) { uint8_t *data; size_t size; int w,h; int has_alpha; #if (WEBP_DECODER_ABI_VERSION >= 0x200) WebPBitstreamFeatures features; #endif char ret = 0; if(im->data) return 0; if(!(data = read_file(im->real_file, &size, progress))) return 0; #if (WEBP_DECODER_ABI_VERSION >= 0x200) if(WebPGetFeatures(data, size, &features) != VP8_STATUS_OK) goto EXIT; w = features.width; h = features.height; has_alpha = features.has_alpha; #else /* compatibility with versions <= 0.1.3 */ if (!WebPGetInfo(data, size, &w, &h)) goto EXIT; has_alpha = 0; #endif if(!im->loader && !im->data) { im->w = w; im->h = h; if(!IMAGE_DIMENSIONS_OK(w, h)) goto EXIT; if(!has_alpha) UNSET_FLAGS(im->flags, F_HAS_ALPHA); else SET_FLAGS(im->flags, F_HAS_ALPHA); im->format = strdup("webp"); } if((!im->data && im->loader) || immediate_load || progress) im->data = (DATA32*)WebPDecodeBGRA(data, size, &w, &h); if(progress) progress(im, 100, 0, 0, 0, 0); ret = 1; EXIT: free(data); return ret; }
void InitParamsVolumeClouds( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, VolumeCloudsVars_t &info ) { // Set material flags SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); SET_FLAGS( MATERIAL_VAR_TRANSLUCENT ); SET_PARAM_FLOAT_IF_NOT_DEFINED( info.m_nTime, 0.0f ); // Set material parameter default values SET_PARAM_FLOAT_IF_NOT_DEFINED( info.m_nRefractAmount, kDefaultRefractAmount ); }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); SET_FLAGS2( MATERIAL_VAR2_LIGHTING_LIGHTMAP ); if( g_pHardwareConfig->GetDXSupportLevel() >= 90 ) { SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); } }
void cpu6502_reset(struct cpu6502_context *context) { context->reg_a = 0x00; context->reg_x = 0x00; context->reg_y = 0x00; context->reg_s = 0xff; SET_FLAGS(context, 0x00); /* FIXME: wrong */ context->pc = context->readfunc(context->cpu, VECTOR_RESET_LO); context->pc |= context->readfunc(context->cpu, VECTOR_RESET_HI) << 8; }
void InitParamsAftershock( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, AftershockVars_t &info ) { // Set material flags SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); SET_FLAGS( MATERIAL_VAR_TRANSLUCENT ); SET_FLAGS2( MATERIAL_VAR2_NEEDS_POWER_OF_TWO_FRAME_BUFFER_TEXTURE ); // Set material parameter default values if ( ( info.m_nRefractAmount != -1 ) && ( !params[info.m_nRefractAmount]->IsDefined() ) ) { params[info.m_nRefractAmount]->SetFloatValue( kDefaultRefractAmount ); } if ( ( info.m_nColorTint != -1 ) && ( !params[info.m_nColorTint]->IsDefined() ) ) { params[info.m_nColorTint]->SetVecValue( kDefaultColorTint[0], kDefaultColorTint[1], kDefaultColorTint[2], kDefaultColorTint[3] ); } if( (info.m_nBumpFrame != -1 ) && !params[info.m_nBumpFrame]->IsDefined() ) { params[info.m_nBumpFrame]->SetIntValue( 0 ); } if ( ( info.m_nSilhouetteThickness != -1 ) && ( !params[info.m_nSilhouetteThickness]->IsDefined() ) ) { params[info.m_nSilhouetteThickness]->SetFloatValue( kDefaultSilhouetteThickness ); } if ( ( info.m_nSilhouetteColor != -1 ) && ( !params[info.m_nSilhouetteColor]->IsDefined() ) ) { params[info.m_nSilhouetteColor]->SetVecValue( kDefaultSilhouetteColor[0], kDefaultSilhouetteColor[1], kDefaultSilhouetteColor[2], kDefaultSilhouetteColor[3] ); } if ( ( info.m_nGroundMin != -1 ) && ( !params[info.m_nGroundMin]->IsDefined() ) ) { params[info.m_nGroundMin]->SetFloatValue( kDefaultGroundMin ); } if ( ( info.m_nGroundMax != -1 ) && ( !params[info.m_nGroundMax]->IsDefined() ) ) { params[info.m_nGroundMax]->SetFloatValue( kDefaultGroundMax ); } if ( ( info.m_nBlurAmount != -1 ) && ( !params[info.m_nBlurAmount]->IsDefined() ) ) { params[info.m_nBlurAmount]->SetFloatValue( kDefaultBlurAmount ); } SET_PARAM_FLOAT_IF_NOT_DEFINED( info.m_nTime, 0.0f ); }
void cosmac_device::state_import(const device_state_entry &entry) { switch (entry.index()) { case STATE_GENPC: R[P] = m_pc; break; case STATE_GENFLAGS: SET_FLAGS(m_flagsio); break; } }
static isc_result_t opensslrsa_fromdns(dst_key_t *key, isc_buffer_t *data) { RSA *rsa; isc_region_t r; unsigned int e_bytes; isc_buffer_remainingregion(data, &r); if (r.length == 0) return (ISC_R_SUCCESS); rsa = RSA_new(); if (rsa == NULL) return (ISC_R_NOMEMORY); SET_FLAGS(rsa); if (r.length < 1) { RSA_free(rsa); return (DST_R_INVALIDPUBLICKEY); } e_bytes = *r.base++; r.length--; if (e_bytes == 0) { if (r.length < 2) { RSA_free(rsa); return (DST_R_INVALIDPUBLICKEY); } e_bytes = ((*r.base++) << 8); e_bytes += *r.base++; r.length -= 2; } if (r.length < e_bytes) { RSA_free(rsa); return (DST_R_INVALIDPUBLICKEY); } rsa->e = BN_bin2bn(r.base, e_bytes, NULL); r.base += e_bytes; r.length -= e_bytes; rsa->n = BN_bin2bn(r.base, r.length, NULL); key->key_size = BN_num_bits(rsa->n); isc_buffer_forward(data, r.length); key->opaque = (void *) rsa; return (ISC_R_SUCCESS); }
// FIXME: doesn't support fresnel! void InitParamsCloak_DX9( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, Cloak_DX9_Vars_t &info ) { SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); SET_FLAGS( MATERIAL_VAR_TRANSLUCENT ); SET_FLAGS2( MATERIAL_VAR2_LIGHTING_VERTEX_LIT ); if( !params[info.m_nFresnelReflection]->IsDefined() ) { params[info.m_nFresnelReflection]->SetFloatValue( 1.0f ); } if( !params[info.m_nMasked]->IsDefined() ) { params[info.m_nMasked]->SetIntValue( 0 ); } SET_FLAGS2( MATERIAL_VAR2_NEEDS_POWER_OF_TWO_FRAME_BUFFER_TEXTURE ); }
BEGIN_SHADER_PARAMS END_SHADER_PARAMS // Set up anything that is necessary to make decisions in SHADER_FALLBACK. SHADER_INIT_PARAMS() { // No texture means no self-illum or env mask in base alpha CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); // If in decal mode, no debug override... if (IS_FLAG_SET(MATERIAL_VAR_DECAL)) { SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); } SET_FLAGS2( MATERIAL_VAR2_LIGHTING_LIGHTMAP ); }
static isc_result_t opensslrsa_generate(dst_key_t *key, int exp) { RSA *rsa; unsigned long e; if (exp == 0) e = RSA_3; else e = RSA_F4; rsa = RSA_generate_key(key->key_size, e, NULL, NULL); if (rsa == NULL) return (dst__openssl_toresult(DST_R_OPENSSLFAILURE)); SET_FLAGS(rsa); key->opaque = rsa; return (ISC_R_SUCCESS); }