/** * 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() { 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(); } }
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 ); } }
/** * Sets a property key to the specified value. If the key does * not exist and <tt>useMalloc<tt> is <tt>KNI_TRUE<tt>, use * <tt>midpMalloc()<tt> to make a copy of the contents of * <tt>key<tt>. If the key does not exist and <tt>useMalloc<tt> * is <tt>KNI_FALSE<tt>, make a copy of the pointer to * <tt>key<tt>. If the <tt>key<tt> already exists in the * property lists, modify its associated value. * * @param propertySet The property set in which to add/modify * <tt>key<tt> * @param key The key to set * @param value The value to associate with <tt>key<tt> * @param useMalloc If <tt>KNI_TRUE<tt>, use <tt>midpMalloc()<tt> * to make a copy of the contents of <tt>value<tt>, * otherwise make a copy of the pointer to * <tt>value<tt>. */ static void setProp(Property** propertySet, const char* key, const char* value, jboolean useMalloc) { Property *p; for (p = *propertySet; p; p = p->next) { if (strcmp(key, p->key) == 0) { if (IS_NEW_VALUE(p)) { midpFree((void *)p->value); } if (useMalloc) { SET_NEW_VALUE(p); p->value = midpStrdup(value); } else { UNSET_NEW_VALUE(p); p->value = value; } /* * if midpStrdup fails we will just return without setting * the value to anything other than NULL */ return; } } /* If the value is not defined, add it now */ p = (Property*)midpMalloc(sizeof(Property)); if (NULL != p){ p->next = *propertySet; CLEAR_FLAGS(p); if (useMalloc) { SET_NEW_VALUE(p); SET_NEW_KEY(p); p->key = midpStrdup(key); p->value = midpStrdup(value); } else { UNSET_NEW_VALUE(p); UNSET_NEW_KEY(p); p->value = value; p->key = key; } if ((p->key == NULL) || (p->value == NULL && value != NULL)) { /* do nothing if there is no memory */ if (useMalloc) { midpFree((void *)p->key); midpFree((void *)p->value); } midpFree((void *)p); return; } *propertySet = p ; } }
extern t_account * create_vaccount(const char *username, unsigned int uid) { /* this is a modified(?) version of account_create */ t_account * account; account = malloc(sizeof(t_account)); if (!account) { eventlog(eventlog_level_error,"create_vaccount","could not allocate memory for account"); return NULL; } account->attrs = NULL; account->age = 0; CLEAR_FLAGS(account); account->namehash = 0; /* hash it later */ account->uid = 0; account->filename = NULL; /* there is no local account file */ account->bits_state = account_state_unknown; if (username) { if (username[0]!='#') { if (strchr(username,' ')) { eventlog(eventlog_level_error,"create_vaccount","username contains spaces"); account_destroy(account); return NULL; } if (strlen(username)>=MAX_USER_NAME) { eventlog(eventlog_level_error,"create_vaccount","username \"%s\" is too long (%u chars)",username,strlen(username)); account_destroy(account); return NULL; } account_set_strattr(account,"BNET\\acct\\username",username); account->namehash = account_hash(username); } else { if (str_to_uint(&username[1],&account->uid)<0) { eventlog(eventlog_level_warn,"create_vaccount","invalid username \"%s\"",username); } } } account_set_numattr(account,"BNET\\acct\\userid",account->uid); return account; }
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 ); }
SHADER_INIT_PARAMS() { SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); if ( g_pHardwareConfig->HasFastVertexTextures() ) SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID ); //const bool bIsDecal = IS_FLAG_SET( MATERIAL_VAR_DECAL ); const bool bDeferredActive = GetDeferredExt()->IsDeferredLightingEnabled(); if( bDeferredActive )// && !bIsDecal ) { const bool bTranslucent = IS_FLAG_SET( MATERIAL_VAR_TRANSLUCENT ); const bool bAlphaTest = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ); if( bTranslucent ) { CLEAR_FLAGS( MATERIAL_VAR_TRANSLUCENT ); SET_FLAGS( MATERIAL_VAR_ALPHATEST ); params[ALPHATESTREFERENCE]->SetFloatValue( 0.5f ); } else if( bAlphaTest ) { if( params[ALPHATESTREFERENCE]->GetFloatValue() == 0.0f ) params[ALPHATESTREFERENCE]->SetFloatValue( 0.5f ); } } const bool bDrawToGBuffer = DrawToGBuffer( params ); if ( bDrawToGBuffer ) { defParms_gBuffer parms_gbuffer; SetupParmsGBuffer( parms_gbuffer ); InitParmsGBuffer( parms_gbuffer, this, params ); defParms_shadow parms_shadow; SetupParmsShadow( parms_shadow ); InitParmsShadowPass( parms_shadow, this, params ); } }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { if( !params[DETAILSCALE]->IsDefined() ) params[DETAILSCALE]->SetFloatValue( 1.0f ); 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[UNLITFACTOR]->IsDefined() ) params[UNLITFACTOR]->SetFloatValue( 0.3f ); if( !params[FRESNELREFLECTION]->IsDefined() ) params[FRESNELREFLECTION]->SetFloatValue( 1.0f ); if( !params[ENVMAPMASKFRAME]->IsDefined() ) params[ENVMAPMASKFRAME]->SetIntValue( 0 ); if( !params[ENVMAPFRAME]->IsDefined() ) params[ENVMAPFRAME]->SetIntValue( 0 ); // 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 ); } }
void methctx_reference(STATE, OBJECT ctx) { struct fast_context *fc; /* Don't do it again. */ if(!stack_context_p(ctx)) return; /* Has to be done first because this uses informated we're about to overwrite. */ object_memory_context_referenced(state->om, ctx); CLEAR_FLAGS(ctx); ctx->gc_zone = YoungObjectZone; switch(FASTCTX(ctx)->type) { case FASTCTX_NORMAL: SET_CLASS(ctx, BASIC_CLASS(fastctx)); ctx->obj_type = MContextType; ctx->CTXFast = TRUE; break; case FASTCTX_BLOCK: SET_CLASS(ctx, BASIC_CLASS(blokctx)); ctx->obj_type = BContextType; break; case FASTCTX_NMC: SET_CLASS(ctx, BASIC_CLASS(nmc)); ctx->obj_type = MContextType; break; } SET_NUM_FIELDS(ctx, FASTCTX_FIELDS); ctx->StoresBytes = TRUE; ctx->ForeverYoung = TRUE; fc = FASTCTX(ctx); /* Fixup the locals tuple. */ if(!NIL_P(fc->locals) && fc->locals->gc_zone == 0) { fc->locals->gc_zone = YoungObjectZone; } }
/************************************************************************ * * * device_init( par, param ) - initialize the device info. * * * * Original: MEL 2/89 * * * ************************************************************************/ device_init( ) { int mat, mat2, i; n_con = 0; n_ckt = 0; dopcalcdone = FALSE; /*Electrons*/ impur[N].diff_coeff = Nmobil;; impur[N].coupling = Ncoupling; impur[N].boundary = Nboundary; impur[N].algebc = NULL; impur[N].active = NULL; impur[N].time_val = time_val; impur[N].block_set = electron_block; /*constants*/ for(mat = 0; mat < MAXMAT; mat++) { for(i = 0; i < 25; i++) { impur[N].constant[mat][i][0] = 0.0; impur[N].constant[mat][i][1] = 0.0; } for(mat2 = 0; mat2 < MAXMAT; mat2++) { impur[N].seg[SEG0][mat][mat2] = 1.0; impur[N].seg[SEGE][mat][mat2] = 0.0; impur[N].seg[TRN0][mat][mat2] = 0.0; impur[N].seg[TRNE][mat][mat2] = 0.0; } } CLEAR_FLAGS(N, ALL_FLAGS); SET_FLAGS(N, PSEUDO); /*interstitials*/ impur[H].diff_coeff = Hmobil; impur[H].coupling = Hcoupling; impur[H].boundary = Hboundary; impur[H].algebc = NULL; impur[H].active = NULL; impur[H].time_val = time_val; impur[H].block_set = hole_block; /*constants*/ for(mat = 0; mat < MAXMAT; mat++) { for(i = 0; i < 25; i++) { impur[H].constant[mat][i][0] = 0.0; impur[H].constant[mat][i][1] = 0.0; } for(mat2 = 0; mat2 < MAXMAT; mat2++) { impur[H].seg[SEG0][mat][mat2] = 1.0; impur[H].seg[SEGE][mat][mat2] = 0.0; impur[H].seg[TRN0][mat][mat2] = 0.0; impur[H].seg[TRNE][mat][mat2] = 0.0; } } CLEAR_FLAGS(H, ALL_FLAGS); SET_FLAGS(H, PSEUDO); /*potential*/ CLEAR_FLAGS(Psi, ALL_FLAGS); SET_FLAGS(N, (MOBILE | DIFFUSING | STEADY | LOCKSTEP) ); impur[Psi].diff_coeff = NULL; impur[Psi].boundary = Psiboundary; impur[Psi].algebc = NULL; impur[Psi].coupling = NULL; impur[Psi].active = NULL; impur[Psi].time_val = NULL; impur[Psi].block_set = poisson_block; for(mat = 0; mat < MAXMAT; mat++) { for(i = 0; i < 25; i++) { impur[Psi].constant[mat][i][0] = 0.0; impur[Psi].constant[mat][i][1] = 0.0; } for(mat2 = 0; mat2 < MAXMAT; mat2++) { impur[Psi].seg[0][mat][mat2] = 0.0; impur[Psi].seg[1][mat][mat2] = 0.0; impur[Psi].seg[2][mat][mat2] = 0.0; impur[Psi].seg[3][mat][mat2] = 0.0; } } /*circuit terms*/ CLEAR_FLAGS(CKT, ALL_FLAGS); impur[CKT].diff_coeff = NULL; impur[CKT].boundary = NULL; impur[CKT].algebc = NULL; impur[CKT].coupling = NULL; impur[CKT].active = NULL; impur[CKT].time_val = NULL; impur[CKT].block_set = circuit_setup; /*these are all useless...*/ for(mat = 0; mat < MAXMAT; mat++) { for(i = 0; i < 25; i++) { impur[Psi].constant[mat][i][0] = 0.0; impur[Psi].constant[mat][i][1] = 0.0; } for(mat2 = 0; mat2 < MAXMAT; mat2++) { impur[Psi].seg[0][mat][mat2] = 0.0; impur[Psi].seg[1][mat][mat2] = 0.0; impur[Psi].seg[2][mat][mat2] = 0.0; impur[Psi].seg[3][mat][mat2] = 0.0; } } }
void InitVertexLitGeneric_DX9( CBaseVSShader *pShader, IMaterialVar** params, bool bVertexLitGeneric, VertexLitGeneric_DX9_Vars_t &info ) { Assert( info.m_nPhong >= 0 ); if( params[info.m_nPhong]->GetIntValue() ) { InitSkin_DX9( pShader, params, true, info ); return; } Assert( info.m_nFlashlightTexture >= 0 ); pShader->LoadTexture( info.m_nFlashlightTexture ); bool bIsBaseTextureTranslucent = false; if ( params[info.m_nBaseTexture]->IsDefined() ) { pShader->LoadTexture( info.m_nBaseTexture ); if ( params[info.m_nBaseTexture]->GetTextureValue()->IsTranslucent() ) { bIsBaseTextureTranslucent = true; } } // No alpha channel in any of the textures? No self illum or envmapmask if ( !bIsBaseTextureTranslucent ) { CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } if ( params[info.m_nDetail]->IsDefined() ) { pShader->LoadTexture( info.m_nDetail ); } if ( g_pConfig->UseBumpmapping() ) { if ( (info.m_nBumpmap != -1) && params[info.m_nBumpmap]->IsDefined() ) { pShader->LoadBumpMap( info.m_nBumpmap ); SET_FLAGS2( MATERIAL_VAR2_DIFFUSE_BUMPMAPPED_MODEL ); } } // Don't alpha test if the alpha channel is used for other purposes if ( IS_FLAG_SET(MATERIAL_VAR_SELFILLUM) || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) ) { CLEAR_FLAGS( MATERIAL_VAR_ALPHATEST ); } if ( params[info.m_nEnvmap]->IsDefined() ) { if( !IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) ) { pShader->LoadCubeMap( info.m_nEnvmap ); } else { pShader->LoadTexture( info.m_nEnvmap ); } if( !g_pHardwareConfig->SupportsCubeMaps() ) { SET_FLAGS( MATERIAL_VAR_ENVMAPSPHERE ); } } if ( params[info.m_nEnvmapMask]->IsDefined() ) { pShader->LoadTexture( info.m_nEnvmapMask ); } }
SHADER_INIT_PARAMS() { if( !params[DETAIL_ALPHA_MASK_BASE_TEXTURE]->IsDefined() ) { params[DETAIL_ALPHA_MASK_BASE_TEXTURE]->SetIntValue( 0 ); } params[FLASHLIGHTTEXTURE]->SetStringValue( GetFlashlightTextureFilename() ); // Write over $basetexture with $albedo if we are going to be using diffuse normal mapping. if( g_pConfig->UseBumpmapping() && params[BUMPMAP]->IsDefined() && params[ALBEDO]->IsDefined() && params[BASETEXTURE]->IsDefined() && !( params[NODIFFUSEBUMPLIGHTING]->IsDefined() && params[NODIFFUSEBUMPLIGHTING]->GetIntValue() ) ) { params[BASETEXTURE]->SetStringValue( params[ALBEDO]->GetStringValue() ); } if( !params[NODIFFUSEBUMPLIGHTING]->IsDefined() ) { params[NODIFFUSEBUMPLIGHTING]->SetIntValue( 0 ); } if( !params[SELFILLUMTINT]->IsDefined() ) { params[SELFILLUMTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); } if( !params[DETAILSCALE]->IsDefined() ) { params[DETAILSCALE]->SetFloatValue( 4.0f ); } if( !params[BUMPFRAME]->IsDefined() ) { params[BUMPFRAME]->SetIntValue( 0 ); } if( !params[DETAILFRAME]->IsDefined() ) { params[DETAILFRAME]->SetIntValue( 0 ); } // 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_LIGHTMAP ); if( g_pConfig->UseBumpmapping() && params[BUMPMAP]->IsDefined() && (params[NODIFFUSEBUMPLIGHTING]->GetIntValue() == 0) ) { SET_FLAGS2( MATERIAL_VAR2_LIGHTING_BUMPED_LIGHTMAP ); } // srgb read 360 InitIntParam( SHADERSRGBREAD360, params, 0 ); }
void InitParamsLightmappedGeneric_DX9( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, LightmappedGeneric_DX9_Vars_t &info ) { if ( g_pHardwareConfig->SupportsBorderColor() ) { params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight_border" ); } else { params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight001" ); } // Write over $basetexture with $albedo if we are going to be using diffuse normal mapping. if( g_pConfig->UseBumpmapping() && params[info.m_nBumpmap]->IsDefined() && params[info.m_nAlbedo]->IsDefined() && params[info.m_nBaseTexture]->IsDefined() && !( params[info.m_nNoDiffuseBumpLighting]->IsDefined() && params[info.m_nNoDiffuseBumpLighting]->GetIntValue() ) ) { params[info.m_nBaseTexture]->SetStringValue( params[info.m_nAlbedo]->GetStringValue() ); } if( pShader->IsUsingGraphics() && params[info.m_nEnvmap]->IsDefined() && !pShader->CanUseEditorMaterials() ) { if( stricmp( params[info.m_nEnvmap]->GetStringValue(), "env_cubemap" ) == 0 ) { Warning( "env_cubemap used on world geometry without rebuilding map. . ignoring: %s\n", pMaterialName ); params[info.m_nEnvmap]->SetUndefined(); } } if ( (mat_disable_lightwarp.GetBool() ) && (info.m_nLightWarpTexture != -1) ) { params[info.m_nLightWarpTexture]->SetUndefined(); } if ( (mat_disable_fancy_blending.GetBool() ) && (info.m_nBlendModulateTexture != -1) ) { params[info.m_nBlendModulateTexture]->SetUndefined(); } if( !params[info.m_nEnvmapTint]->IsDefined() ) params[info.m_nEnvmapTint]->SetVecValue( 1.0f, 1.0f, 1.0f ); if( !params[info.m_nNoDiffuseBumpLighting]->IsDefined() ) params[info.m_nNoDiffuseBumpLighting]->SetIntValue( 0 ); if( !params[info.m_nSelfIllumTint]->IsDefined() ) params[info.m_nSelfIllumTint]->SetVecValue( 1.0f, 1.0f, 1.0f ); if( !params[info.m_nDetailScale]->IsDefined() ) params[info.m_nDetailScale]->SetFloatValue( 4.0f ); if ( !params[info.m_nDetailTint]->IsDefined() ) params[info.m_nDetailTint]->SetVecValue( 1.0f, 1.0f, 1.0f, 1.0f ); InitFloatParam( info.m_nDetailTextureBlendFactor, params, 1.0 ); InitIntParam( info.m_nDetailTextureCombineMode, params, 0 ); if( !params[info.m_nFresnelReflection]->IsDefined() ) params[info.m_nFresnelReflection]->SetFloatValue( 1.0f ); if( !params[info.m_nEnvmapMaskFrame]->IsDefined() ) params[info.m_nEnvmapMaskFrame]->SetIntValue( 0 ); if( !params[info.m_nEnvmapFrame]->IsDefined() ) params[info.m_nEnvmapFrame]->SetIntValue( 0 ); if( !params[info.m_nBumpFrame]->IsDefined() ) params[info.m_nBumpFrame]->SetIntValue( 0 ); if( !params[info.m_nDetailFrame]->IsDefined() ) params[info.m_nDetailFrame]->SetIntValue( 0 ); 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 ); InitFloatParam( info.m_nAlphaTestReference, params, 0.0f ); // No texture means no self-illum or env mask in base alpha if ( !params[info.m_nBaseTexture]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } if( params[info.m_nBumpmap]->IsDefined() ) { params[info.m_nEnvmapMask]->SetUndefined(); } // 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 ); if( g_pConfig->UseBumpmapping() && params[info.m_nBumpmap]->IsDefined() && (params[info.m_nNoDiffuseBumpLighting]->GetIntValue() == 0) ) { SET_FLAGS2( MATERIAL_VAR2_LIGHTING_BUMPED_LIGHTMAP ); } // If mat_specular 0, then get rid of envmap if( !g_pConfig->UseSpecular() && params[info.m_nEnvmap]->IsDefined() && params[info.m_nBaseTexture]->IsDefined() ) { params[info.m_nEnvmap]->SetUndefined(); } if( !params[info.m_nBaseTextureNoEnvmap]->IsDefined() ) { params[info.m_nBaseTextureNoEnvmap]->SetIntValue( 0 ); } if( !params[info.m_nBaseTexture2NoEnvmap]->IsDefined() ) { params[info.m_nBaseTexture2NoEnvmap]->SetIntValue( 0 ); } if( ( info.m_nSelfShadowedBumpFlag != -1 ) && ( !params[info.m_nSelfShadowedBumpFlag]->IsDefined() ) ) { params[info.m_nSelfShadowedBumpFlag]->SetIntValue( 0 ); } // handle line art parms InitFloatParam( info.m_nEdgeSoftnessStart, params, 0.5 ); InitFloatParam( info.m_nEdgeSoftnessEnd, params, 0.5 ); InitFloatParam( info.m_nOutlineAlpha, params, 1.0 ); // Parallax cubemaps //cubemap parallax correction requires all 4 lines (if the 2nd, 3rd, or 4th are undef, undef the first one (checking done on first var) if (!(params[info.m_nEnvmapParallaxObb2]->IsDefined() && params[info.m_nEnvmapParallaxObb3]->IsDefined() && params[info.m_nEnvmapOrigin]->IsDefined())) { params[info.m_nEnvmapParallaxObb1]->SetUndefined(); } }
// Set up anything that is necessary to make decisions in SHADER_FALLBACK. SHADER_INIT_PARAMS() { // FLASHLIGHTFIXME params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight001" ); // Write over $basetexture with $albedo if we are going to be using diffuse normal mapping. if( ShouldUseBumpmapping( params ) && params[ALBEDO]->IsDefined() && params[BASETEXTURE]->IsDefined() && !( params[NODIFFUSEBUMPLIGHTING]->IsDefined() && params[NODIFFUSEBUMPLIGHTING]->GetIntValue() ) ) { params[BASETEXTURE]->SetStringValue( params[ALBEDO]->GetStringValue() ); } if( IsUsingGraphics() && params[ENVMAP]->IsDefined() && !CanUseEditorMaterials() ) { if( stricmp( params[ENVMAP]->GetStringValue(), "env_cubemap" ) == 0 ) { Warning( "env_cubemap used on world geometry without rebuilding map. . ignoring: %s\n", pMaterialName ); params[ENVMAP]->SetUndefined(); } } 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 ); } if( !params[DETAILBLENDFACTOR]->IsDefined() ) { params[DETAILBLENDFACTOR]->SetFloatValue( 1.0f ); } if( !params[FRESNELREFLECTION]->IsDefined() ) { params[FRESNELREFLECTION]->SetFloatValue( 1.0f ); } if( !params[ENVMAPMASKFRAME]->IsDefined() ) { params[ENVMAPMASKFRAME]->SetIntValue( 0 ); } if( !params[ENVMAPFRAME]->IsDefined() ) { params[ENVMAPFRAME]->SetIntValue( 0 ); } if( !params[BUMPFRAME]->IsDefined() ) { params[BUMPFRAME]->SetIntValue( 0 ); } if( !params[ENVMAPCONTRAST]->IsDefined() ) { params[ENVMAPCONTRAST]->SetFloatValue( 0.0f ); } if( !params[ENVMAPSATURATION]->IsDefined() ) { params[ENVMAPSATURATION]->SetFloatValue( 1.0f ); } if( !params[ALPHATESTREFERENCE]->IsDefined() ) { params[ALPHATESTREFERENCE]->SetFloatValue( 0.0f ); } // 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_LIGHTMAP ); if( ShouldUseBumpmapping( params ) && (params[NODIFFUSEBUMPLIGHTING]->GetIntValue() == 0) ) { SET_FLAGS2( MATERIAL_VAR2_LIGHTING_BUMPED_LIGHTMAP ); } // Get rid of the envmap if it's optional for this dx level. if( params[ENVMAPOPTIONAL]->IsDefined() && (params[ENVMAPOPTIONAL]->GetIntValue() > g_pHardwareConfig->GetDXSupportLevel()) ) { 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(); } if( params[SEAMLESS_SCALE]->IsDefined() && params[SEAMLESS_SCALE]->GetFloatValue() != 0.0f ) { if( params[BUMPMAP]->IsDefined() ) { Warning( "Can't use $bumpmap with $seamless_scale for lightmappedgeneric_dx8. Implicitly disabling $bumpmap: %s\n", pMaterialName ); params[BUMPMAP]->SetUndefined(); } if( params[ENVMAP]->IsDefined() ) { Warning( "Can't use $envmap with $seamless_scale for lightmappedgeneric_dx8. Implicitly disabling $envmap: %s\n", pMaterialName ); params[ENVMAP]->SetUndefined(); } } if ( !params[SEAMLESS_SCALE]->IsDefined() ) { // zero means don't do seamless mapping. params[SEAMLESS_SCALE]->SetFloatValue( 0.0f ); } // Get rid of envmap if we aren't using bumpmapping // *and* we have normalmapalphaenvmapmask *and* we don't have envmapmask elsewhere if ( params[ENVMAP]->IsDefined() && params[BUMPMAP]->IsDefined() && IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ) && !ShouldUseBumpmapping( params ) ) { if ( !IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) && !params[ENVMAPMASK]->IsDefined() ) { params[ENVMAP]->SetUndefined(); } } }
//----------------------------------------------------------------------------- // Initialize shader parameters //----------------------------------------------------------------------------- void InitParamsVertexLitGeneric_DX9( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, bool bVertexLitGeneric, VertexLitGeneric_DX9_Vars_t &info ) { Assert( info.m_nPhong >= 0 ); Assert( info.m_nPhongExponent >= 0 ); Assert( info.m_nPhongExponentTexture >= 0 ); Assert( info.m_nLightWarpTexture >= 0 ); Assert( info.m_nPhongBoost >= 0 ); Assert( info.m_nPhongFresnelRanges >= 0 ); if( !params[info.m_nPhong]->IsDefined() ) { params[info.m_nPhong]->SetIntValue( 0 ); } if( params[info.m_nPhong]->GetIntValue() != 0 ) { if( g_pHardwareConfig->GetDXSupportLevel() < 90 ) { params[info.m_nPhong]->SetIntValue( 0 ); } else { InitParamsSkin_DX9( pShader, params, pMaterialName, true, info ); return; } } // FLASHLIGHTFIXME: Do ShaderAPI::BindFlashlightTexture Assert( info.m_nFlashlightTexture >= 0 ); params[info.m_nFlashlightTexture]->SetStringValue( "effects/flashlight001" ); // 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() ); } if( bVertexLitGeneric ) { SET_FLAGS( MATERIAL_VAR_MODEL ); SET_FLAGS2( MATERIAL_VAR2_LIGHTING_VERTEX_LIT ); } else { CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); } if( !params[info.m_nEnvmapMaskFrame]->IsDefined() ) { params[info.m_nEnvmapMaskFrame]->SetIntValue( 0 ); } if( !params[info.m_nEnvmapTint]->IsDefined() ) { params[info.m_nEnvmapTint]->SetVecValue( 1.0f, 1.0f, 1.0f ); } if( (info.m_nSelfIllumTint != -1) && (!params[info.m_nSelfIllumTint]->IsDefined()) ) { params[info.m_nSelfIllumTint]->SetVecValue( 1.0f, 1.0f, 1.0f ); } if( !params[info.m_nDetailScale]->IsDefined() ) { params[info.m_nDetailScale]->SetFloatValue( 4.0f ); } // With HDR, we don't support envmap contrast and saturation since they were // trying to emulate HDR effects. if( !params[info.m_nEnvmapContrast]->IsDefined()) { params[info.m_nEnvmapContrast]->SetFloatValue( 0.0f ); } // With HDR, we don't support envmap contrast and saturation since they were // trying to emulate HDR effects. 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( (info.m_nBumpFrame != -1) && !params[info.m_nBumpFrame]->IsDefined() ) { params[info.m_nBumpFrame]->SetIntValue( 0 ); } // No texture means no self-illum or env mask in base alpha if ( !params[info.m_nBaseTexture]->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 ); } if( ( (info.m_nBumpmap != -1) && g_pConfig->UseBumpmapping() && params[info.m_nBumpmap]->IsDefined() ) || params[info.m_nEnvmap]->IsDefined() ) { SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); } else { CLEAR_FLAGS( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ); } bool hasNormalMapAlphaEnvmapMask = IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ); if( hasNormalMapAlphaEnvmapMask ) { params[info.m_nEnvmapMask]->SetUndefined(); CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } if( IS_FLAG_SET( MATERIAL_VAR_BASEALPHAENVMAPMASK ) && info.m_nBumpmap != -1 && params[info.m_nBumpmap]->IsDefined() && !hasNormalMapAlphaEnvmapMask ) { Warning( "material %s has a normal map and $basealphaenvmapmask. Must use $normalmapalphaenvmapmask to get specular.\n\n", pMaterialName ); params[info.m_nEnvmap]->SetUndefined(); } if( params[info.m_nEnvmapMask]->IsDefined() && info.m_nBumpmap != -1 && params[info.m_nBumpmap]->IsDefined() ) { params[info.m_nEnvmapMask]->SetUndefined(); if( !hasNormalMapAlphaEnvmapMask ) { Warning( "material %s has a normal map and an envmapmask. Must use $normalmapalphaenvmapmask.\n\n", pMaterialName ); params[info.m_nEnvmap]->SetUndefined(); } } // If mat_specular 0, then get rid of envmap if( !g_pConfig->UseSpecular() && params[info.m_nEnvmap]->IsDefined() && params[info.m_nBaseTexture]->IsDefined() ) { params[info.m_nEnvmap]->SetUndefined(); } if( ( info.m_nHDRColorScale != -1 ) && !params[info.m_nHDRColorScale]->IsDefined() ) { params[info.m_nHDRColorScale]->SetFloatValue( 1.0f ); } }
void InitLightmappedGeneric_DX9( CBaseVSShader *pShader, IMaterialVar** params, LightmappedGeneric_DX9_Vars_t &info ) { if ( g_pConfig->UseBumpmapping() && params[info.m_nBumpmap]->IsDefined() ) { pShader->LoadBumpMap( info.m_nBumpmap ); } if ( g_pConfig->UseBumpmapping() && params[info.m_nBumpmap2]->IsDefined() ) { pShader->LoadBumpMap( info.m_nBumpmap2 ); } if ( g_pConfig->UseBumpmapping() && params[info.m_nBumpMask]->IsDefined() ) { pShader->LoadBumpMap( info.m_nBumpMask ); } if (params[info.m_nBaseTexture]->IsDefined()) { pShader->LoadTexture( info.m_nBaseTexture, TEXTUREFLAGS_SRGB ); if (!params[info.m_nBaseTexture]->GetTextureValue()->IsTranslucent()) { CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } } if (params[info.m_nBaseTexture2]->IsDefined() ) { pShader->LoadTexture( info.m_nBaseTexture2, TEXTUREFLAGS_SRGB ); } if (params[info.m_nLightWarpTexture]->IsDefined() ) { pShader->LoadTexture( info.m_nLightWarpTexture ); } if ((info.m_nBlendModulateTexture != -1) && (params[info.m_nBlendModulateTexture]->IsDefined()) ) { pShader->LoadTexture( info.m_nBlendModulateTexture ); } if (params[info.m_nDetail]->IsDefined()) { int nDetailBlendMode = ( info.m_nDetailTextureCombineMode == -1 ) ? 0 : params[info.m_nDetailTextureCombineMode]->GetIntValue(); nDetailBlendMode = nDetailBlendMode > 1 ? 1 : nDetailBlendMode; pShader->LoadTexture( info.m_nDetail, nDetailBlendMode != 0 ? TEXTUREFLAGS_SRGB : 0 ); } pShader->LoadTexture( info.m_nFlashlightTexture, TEXTUREFLAGS_SRGB ); // Don't alpha test if the alpha channel is used for other purposes if (IS_FLAG_SET(MATERIAL_VAR_SELFILLUM) || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) ) { CLEAR_FLAGS( MATERIAL_VAR_ALPHATEST ); } if (params[info.m_nEnvmap]->IsDefined()) { if ( !IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) ) { pShader->LoadCubeMap( info.m_nEnvmap, g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE ? TEXTUREFLAGS_SRGB : 0 ); } else { pShader->LoadTexture( info.m_nEnvmap ); } if ( !g_pHardwareConfig->SupportsCubeMaps() ) { SET_FLAGS( MATERIAL_VAR_ENVMAPSPHERE ); } if ( params[info.m_nEnvmapMask]->IsDefined() ) { pShader->LoadTexture( info.m_nEnvmapMask ); } } else { params[info.m_nEnvmapMask]->SetUndefined(); } // We always need this because of the flashlight. SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); }
//----------------------------------------------------------------------------- // Initialize shader parameters //----------------------------------------------------------------------------- void InitParamsSkin_DX9( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, VertexLitGeneric_DX9_Vars_t &info ) { // FLASHLIGHTFIXME: Do ShaderAPI::BindFlashlightTexture Assert( info.m_nFlashlightTexture >= 0 ); if ( g_pHardwareConfig->SupportsBorderColor() ) { params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight_border" ); } else { params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight001" ); } // 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 ); } // Lots of reasons to want tangent space, since we bind a flat normal map in many cases where we don't have a bump map 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 ) { SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); } else { CLEAR_FLAGS( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ); } if ( ( info.m_nSelfIllumFresnel != -1 ) && ( !params[info.m_nSelfIllumFresnel]->IsDefined() ) ) { params[info.m_nSelfIllumFresnel]->SetIntValue( 0 ); } if ( ( info.m_nSelfIllumFresnelMinMaxExp != -1 ) && ( !params[info.m_nSelfIllumFresnelMinMaxExp]->IsDefined() ) ) { params[info.m_nSelfIllumFresnelMinMaxExp]->SetVecValue( 0.0f, 1.0f, 1.0f ); } if ( ( info.m_nBaseMapAlphaPhongMask != -1 ) && ( !params[info.m_nBaseMapAlphaPhongMask]->IsDefined() ) ) { params[info.m_nBaseMapAlphaPhongMask]->SetIntValue( 0 ); } if ( ( info.m_nEnvmapFresnel != -1 ) && ( !params[info.m_nEnvmapFresnel]->IsDefined() ) ) { params[info.m_nEnvmapFresnel]->SetFloatValue( 0 ); } }
int main (int argc, char** argv) { char *kfile, *tfile, *cfile, *tafile, *lfile; size_t ksize, tsize, iter, depth; // FILE *kout, *tout; char opt; graph_t **gtrain; int* target; FILE* fileTrain, *fileResult, *fileTarget; core_t core; gtrain = NULL; lfile = tafile = cfile = kfile = NULL; depth = 3; CLEAR_FLAGS(); SET_RUNNABLE(); ksize = tsize = 0; core = TanimotoCore; while((opt = getopt(argc, argv, "mvihd:k:t:c:a:l:")) != -1) { switch(opt){ case 'v': SET_VERBOSE(); break; case 'i': SET_INFO(); break; case 'd': depth = strtol((const char*) optarg, 0, 10); break; case 'k': SET_K_FILE(); kfile = optarg; break; case 't': SET_T_FILE(); tfile = optarg; break; case 'c': SET_C_FILE(); cfile = optarg; break; case 'a': SET_TA_FILE(); tafile = optarg; break; case 'l': SET_L_FILE(); lfile = optarg; break; case 'h': SET_HELP(); break; case 'm': SET_PROVA_MINMAX(); break; default: SET_HELP(); } } if(HELP()) { usage(); CLEAR_FLAGS(); } if(INFO()) { info(); CLEAR_FLAGS(); } if(optind < argc) { if(!strcmp(argv[optind], "tanimoto")) { printf("tanimoto kernel\n"); } else if(!strcmp(argv[optind], "minmax")) { printf("minmax kernel\n"); core = MinMaxCore; } else printf("unavailable core ...\ndefault core: tanimoto\n"); } //else //printf("default core: tanimoto\n"); if(RUNNABLE()) { if(K_FILE() && T_FILE()) { if((fileTrain = fopen(kfile, "r")) && (fileTarget = fopen(tfile, "r"))) { gtrain = parse(fileTrain, &ksize); fclose(fileTrain); target=parseTarget(fileTarget, ksize); fclose(fileTarget); if(target==0) printf("\ncheck training file and target file"); else FoldCrossValidation(core, gtrain, target, ksize, depth); for(iter = 0; iter < ksize; iter++) free_graph(gtrain[iter]); XFREE(gtrain); XFREE(target); }else fatal("unable to open training file"); } if(TA_FILE() && C_FILE()) { fileResult = fopen(cfile, "r"); fileTarget = fopen(tafile, "r"); printf("\nAccuratezza: %f\n", getAccuracy(fileTarget, fileResult)); fclose(fileResult); fclose(fileTarget); } /* if(L_FILE()) { file = fopen(lfile, "r"); printf("\nLeaveOneOut: %f\n", getLeaveOneOut(file)); fclose(file); } */ if(K_FILE() && !T_FILE()) { if((fileTrain = fopen(kfile, "r"))) { gtrain = parse(fileTrain, &ksize); fclose(fileTrain); print_graph(gtrain[0]); print_graph(gtrain[1]); if(gtrain==0) printf("\ncheck training file"); else WriteKernelMatrix(core, gtrain, ksize, depth); for(iter = 0; iter < ksize; iter++) free_graph(gtrain[iter]); XFREE(gtrain); }else fatal("unable to open training file"); } if(PROVA_MINMAX()) { printf("\nPROVA MIN MAX\n"); fileTrain = fopen("./minmax.mol2", "r"); gtrain = parse(fileTrain, &ksize); //print_graph(gtrain[0]); //print_graph(gtrain[1]); print_graph(gtrain[0]); print_graph(gtrain[1]); printf("\nMinMax: %f", MinMaxCore(gtrain[0], gtrain[1], 3)); //printf("\nTanimoto: %f", TanimotoCore(gtrain[0], gtrain[1], 3)); fclose(fileTrain); } } //else usage(); return EXIT_SUCCESS; }
//----------------------------------------------------------------------------- // Initialize shader //----------------------------------------------------------------------------- void InitSkin_DX9( CBaseVSShader *pShader, IMaterialVar** params, VertexLitGeneric_DX9_Vars_t &info ) { Assert( info.m_nFlashlightTexture >= 0 ); pShader->LoadTexture( info.m_nFlashlightTexture, TEXTUREFLAGS_SRGB ); bool bIsBaseTextureTranslucent = false; if ( params[info.m_nBaseTexture]->IsDefined() ) { pShader->LoadTexture( info.m_nBaseTexture, TEXTUREFLAGS_SRGB ); if ( params[info.m_nBaseTexture]->GetTextureValue()->IsTranslucent() ) { bIsBaseTextureTranslucent = true; } if ( ( info.m_nWrinkle != -1 ) && ( info.m_nStretch != -1 ) && params[info.m_nWrinkle]->IsDefined() && params[info.m_nStretch]->IsDefined() ) { pShader->LoadTexture( info.m_nWrinkle, TEXTUREFLAGS_SRGB ); pShader->LoadTexture( info.m_nStretch, TEXTUREFLAGS_SRGB ); } } bool bHasSelfIllumMask = IS_FLAG_SET( MATERIAL_VAR_SELFILLUM ) && (info.m_nSelfIllumMask != -1) && params[info.m_nSelfIllumMask]->IsDefined(); // No alpha channel in any of the textures? No self illum or envmapmask if ( !bIsBaseTextureTranslucent ) { bool bHasSelfIllumFresnel = IS_FLAG_SET( MATERIAL_VAR_SELFILLUM ) && ( info.m_nSelfIllumFresnel != -1 ) && ( params[info.m_nSelfIllumFresnel]->GetIntValue() != 0 ); // Can still be self illum with no base alpha if using one of these alternate modes if ( !bHasSelfIllumFresnel && !bHasSelfIllumMask ) { CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); } CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } if ( (info.m_nPhongExponentTexture != -1) && params[info.m_nPhongExponentTexture]->IsDefined() && (info.m_nPhong != -1) && params[info.m_nPhong]->IsDefined() ) { pShader->LoadTexture( info.m_nPhongExponentTexture ); } if ( (info.m_nDiffuseWarpTexture != -1) && params[info.m_nDiffuseWarpTexture]->IsDefined() && (info.m_nPhong != -1) && params[info.m_nPhong]->IsDefined() ) { pShader->LoadTexture( info.m_nDiffuseWarpTexture ); } if ( (info.m_nPhongWarpTexture != -1) && params[info.m_nPhongWarpTexture]->IsDefined() && (info.m_nPhong != -1) && params[info.m_nPhong]->IsDefined() ) { pShader->LoadTexture( info.m_nPhongWarpTexture ); } if ( info.m_nDetail != -1 && params[info.m_nDetail]->IsDefined() ) { int nDetailBlendMode = ( info.m_nDetailTextureCombineMode == -1 ) ? 0 : params[info.m_nDetailTextureCombineMode]->GetIntValue(); if ( nDetailBlendMode == 0 ) // Mod2X pShader->LoadTexture( info.m_nDetail ); else pShader->LoadTexture( info.m_nDetail, TEXTUREFLAGS_SRGB ); } if ( g_pConfig->UseBumpmapping() ) { if ( (info.m_nBumpmap != -1) && params[info.m_nBumpmap]->IsDefined() ) { pShader->LoadBumpMap( info.m_nBumpmap ); SET_FLAGS2( MATERIAL_VAR2_DIFFUSE_BUMPMAPPED_MODEL ); if ( ( info.m_nNormalWrinkle != -1 ) && ( info.m_nNormalStretch != -1 ) && params[info.m_nNormalWrinkle]->IsDefined() && params[info.m_nNormalStretch]->IsDefined() ) { pShader->LoadTexture( info.m_nNormalWrinkle ); pShader->LoadTexture( info.m_nNormalStretch ); } } } if ( params[info.m_nEnvmap]->IsDefined() ) { pShader->LoadCubeMap( info.m_nEnvmap, g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE ? TEXTUREFLAGS_SRGB : 0 ); } if ( bHasSelfIllumMask ) { pShader->LoadTexture( info.m_nSelfIllumMask ); } }
extern t_account * account_create(char const * username, char const * passhash1) { t_account * account; if (username && account_check_name(username)<0) { eventlog(eventlog_level_error,"account_create","got bad account name"); return NULL; } if (!(account = malloc(sizeof(t_account)))) { eventlog(eventlog_level_error,"account_create","could not allocate memory for account"); return NULL; } account->filename = NULL; account->attrs = NULL; account->age = 0; CLEAR_FLAGS(account); account->namehash = 0; /* hash it later before inserting */ #ifndef ACCT_DYN_LOAD account->uid = 0; #endif /* !ACCT_DYN_LOAD */ #ifdef ACCT_DYN_UNLOAD account->ref = 0; #endif /* ACCT_DYN_UNLOAD */ if (username) /* actually making a new account */ { char * temp; if (account_check_name(username)<0) { eventlog(eventlog_level_error,"account_create","invalid account name \"%s\"",username); account_destroy(account); return NULL; } if (!passhash1) { eventlog(eventlog_level_error,"account_create","got NULL passhash1"); account_destroy(account); return NULL; } #ifdef WITH_STORAGE_DB /* In DB (MySQL) storage i always use the real login name as id */ if (!(temp = malloc(strlen(username)+1))) /* name + NUL */ { eventlog(eventlog_level_error,"account_create","could not allocate memory for temp"); account_destroy(account); return NULL; } sprintf(temp,"%s",username); #else # ifndef ACCT_DYN_LOAD if (prefs_get_savebyname()==0) { if (!(temp = malloc(strlen(prefs_get_userdir())+1+8+1))) /* dir + / + uid + NUL */ { eventlog(eventlog_level_error,"account_create","could not allocate memory for temp"); account_destroy(account); return NULL; } sprintf(temp,"%s/%06u",prefs_get_userdir(),maxuserid+1); /* FIXME: hmm, maybe up the %06 to %08... */ } else # endif /* ! ACCT_DYN_LOAD */ { char const * safename; char * filename; if (!(filename = strdup(username))) { eventlog(eventlog_level_error,"account_create","could not allocate memory for filename"); account_destroy(account); return NULL; } str_to_lower(filename); if (!(safename = escape_fs_chars(filename,strlen(filename)))) { eventlog(eventlog_level_error,"account_create","could not escape username"); account_destroy(account); free(filename); return NULL; } free(filename); if (!(temp = malloc(strlen(prefs_get_userdir())+1+strlen(safename)+1))) /* dir + / + name + NUL */ { eventlog(eventlog_level_error,"account_create","could not allocate memory for temp"); account_destroy(account); return NULL; } sprintf(temp,"%s/%s",prefs_get_userdir(),safename); free((void *)safename); /* avoid warning */ } #endif /* WITH_DB_STORAGE */ account->filename = temp; SET_FLAG(account,account_flag_loaded); if (account_set_strattr(account,"BNET\\acct\\username",username)<0) { eventlog(eventlog_level_error,"account_create","could not set username"); account_destroy(account); return NULL; } #ifndef ACCT_DYN_LOAD if (account_set_numattr(account,"BNET\\acct\\userid",maxuserid+1)<0) { eventlog(eventlog_level_error,"account_create","could not set userid"); account_destroy(account); return NULL; } #endif /* !ACCT_DYN_LOAD */ if (account_set_strattr(account,"BNET\\acct\\passhash1",passhash1)<0) { eventlog(eventlog_level_error,"account_create","could not set passhash1"); account_destroy(account); return NULL; } #ifdef WITH_BITS account_set_bits_state(account,account_state_valid); if (!bits_master) { eventlog(eventlog_level_warn,"account_create","account_create should not be called on BITS clients"); } #endif /* WITH_BITS */ } #ifdef WITH_BITS else /* empty account to be filled in later */ account_set_bits_state(account,account_state_valid); #endif /* WITH_BITS */ return account; }
END_SHADER_PARAMS SHADER_INIT_PARAMS() { // FLASHLIGHTFIXME params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight001" ); // We don't want no stinking bump mapping on models in dx8. // Wait a minute! We want specular bump. .need to make that work by itself. // params[BUMPMAP]->SetUndefined(); // if( IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ) ) // { // CLEAR_FLAGS( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ); // params[ENVMAP]->SetUndefined(); // } // default to 'MODEL' mode... if (!IS_FLAG_DEFINED( MATERIAL_VAR_MODEL )) SET_FLAGS( MATERIAL_VAR_MODEL ); if( !params[ENVMAPMASKSCALE]->IsDefined() ) params[ENVMAPMASKSCALE]->SetFloatValue( 1.0f ); if( !params[ENVMAPMASKFRAME]->IsDefined() ) params[ENVMAPMASKFRAME]->SetIntValue( 0 ); 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 ); 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[BUMPFRAME]->IsDefined() ) params[BUMPFRAME]->SetIntValue( 0 ); // 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 ); } // Force software skinning if the file says so if (!IS_FLAG_SET(MATERIAL_VAR_NEEDS_SOFTWARE_SKINNING)) { #ifdef DIFFUSE_BUMP_ON_DX8 // Software skin if diffuse bump mapping is used at all. if( g_pConfig->bBumpmap && ( ( params[BASETEXTURE]->IsDefined() && params[BUMPMAP]->IsDefined() ) || ( params[BUMPMAP]->IsDefined() && !params[ENVMAP]->IsDefined() ) ) ) { SET_FLAGS( MATERIAL_VAR_NEEDS_SOFTWARE_SKINNING ); } #endif } if( g_pConfig->UseBumpmapping() && params[BUMPMAP]->IsDefined() ) { SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); } SET_FLAGS2( MATERIAL_VAR2_LIGHTING_VERTEX_LIT ); if( !params[DETAIL]->IsDefined() && !params[BUMPMAP]->IsDefined() ) { SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_TEXKILL ); } // 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 InitLightmappedGeneric_DX9( CBaseVSShader *pShader, IMaterialVar** params, LightmappedGeneric_DX9_Vars_t &info ) { bool hasNormalMapAlphaEnvmapMask = g_pConfig->UseSpecular() && IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ); if ( ( g_pConfig->UseBumpmapping() || hasNormalMapAlphaEnvmapMask ) && params[info.m_nBumpmap]->IsDefined() ) { pShader->LoadBumpMap( info.m_nBumpmap ); } if ( g_pConfig->UseBumpmapping() && params[info.m_nBumpmap2]->IsDefined() ) { pShader->LoadBumpMap( info.m_nBumpmap2 ); } if ( g_pConfig->UseBumpmapping() && params[info.m_nBumpMask]->IsDefined() ) { pShader->LoadBumpMap( info.m_nBumpMask ); } if (params[info.m_nBaseTexture]->IsDefined()) { pShader->LoadTexture( info.m_nBaseTexture ); if (!params[info.m_nBaseTexture]->GetTextureValue()->IsTranslucent()) { CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } } if (params[info.m_nBaseTexture2]->IsDefined() ) { pShader->LoadTexture( info.m_nBaseTexture2 ); } if ((info.m_nBlendModulateTexture != -1) && (params[info.m_nBlendModulateTexture]->IsDefined()) ) { pShader->LoadTexture( info.m_nBlendModulateTexture ); } if (params[info.m_nDetail]->IsDefined()) { int nDetailBlendMode = ( info.m_nDetailTextureCombineMode == -1 ) ? 0 : params[info.m_nDetailTextureCombineMode]->GetIntValue(); nDetailBlendMode = nDetailBlendMode > 1 ? 1 : nDetailBlendMode; if ( nDetailBlendMode == 0 ) //Mod2X pShader->LoadTexture( info.m_nDetail ); else pShader->LoadTexture( info.m_nDetail ); } pShader->LoadTexture( info.m_nFlashlightTexture ); // Don't alpha test if the alpha channel is used for other purposes if (IS_FLAG_SET(MATERIAL_VAR_SELFILLUM) || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) ) { CLEAR_FLAGS( MATERIAL_VAR_ALPHATEST ); } if ( g_pConfig->UseSpecular() ) { if ( params[info.m_nEnvmap]->IsDefined() ) { pShader->LoadCubeMap( info.m_nEnvmap ); if (params[info.m_nEnvmapMask]->IsDefined()) { pShader->LoadTexture( info.m_nEnvmapMask ); } } else { params[info.m_nEnvmapMask]->SetUndefined(); } } else { params[info.m_nEnvmap]->SetUndefined(); params[info.m_nEnvmapMask]->SetUndefined(); } // We always need this because of the flashlight. SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); if( IS_PARAM_DEFINED( info.m_nPaintSplatNormal ) ) { pShader->LoadBumpMap( info.m_nPaintSplatNormal ); } if( IS_PARAM_DEFINED( info.m_nPaintSplatEnvMap ) ) { pShader->LoadCubeMap( info.m_nPaintSplatEnvMap ); } if ( IS_PARAM_DEFINED( info.m_nFoW ) ) { pShader->LoadTexture( info.m_nFoW ); } }
void InitParamsLightmappedGeneric_DX9( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, LightmappedGeneric_DX9_Vars_t &info ) { // Override vertex fog via the global setting if it isn't enabled/disabled in the material file. if ( !IS_FLAG_DEFINED( MATERIAL_VAR_VERTEXFOG ) && mat_force_vertexfog.GetBool() ) { SET_FLAGS( MATERIAL_VAR_VERTEXFOG ); } params[FLASHLIGHTTEXTURE]->SetStringValue( GetFlashlightTextureFilename() ); // Write over $basetexture with $albedo if we are going to be using diffuse normal mapping. if( g_pConfig->UseBumpmapping() && params[info.m_nBumpmap]->IsDefined() && params[info.m_nAlbedo]->IsDefined() && params[info.m_nBaseTexture]->IsDefined() && !( params[info.m_nNoDiffuseBumpLighting]->IsDefined() && params[info.m_nNoDiffuseBumpLighting]->GetIntValue() ) ) { params[info.m_nBaseTexture]->SetStringValue( params[info.m_nAlbedo]->GetStringValue() ); } if( pShader->IsUsingGraphics() && params[info.m_nEnvmap]->IsDefined() && !pShader->CanUseEditorMaterials() ) { if( stricmp( params[info.m_nEnvmap]->GetStringValue(), "env_cubemap" ) == 0 ) { Warning( "env_cubemap used on world geometry without rebuilding map. . ignoring: %s\n", pMaterialName ); params[info.m_nEnvmap]->SetUndefined(); } } if ( (mat_disable_lightwarp.GetBool() ) && (info.m_nLightWarpTexture != -1) ) { params[info.m_nLightWarpTexture]->SetUndefined(); } if ( (mat_disable_fancy_blending.GetBool() ) && (info.m_nBlendModulateTexture != -1) ) { params[info.m_nBlendModulateTexture]->SetUndefined(); } if( !params[info.m_nEnvmapTint]->IsDefined() ) params[info.m_nEnvmapTint]->SetVecValue( 1.0f, 1.0f, 1.0f ); if( !params[info.m_nNoDiffuseBumpLighting]->IsDefined() ) params[info.m_nNoDiffuseBumpLighting]->SetIntValue( 0 ); if( !params[info.m_nSelfIllumTint]->IsDefined() ) params[info.m_nSelfIllumTint]->SetVecValue( 1.0f, 1.0f, 1.0f ); if( !params[info.m_nDetailScale]->IsDefined() ) params[info.m_nDetailScale]->SetFloatValue( 4.0f ); if ( !params[info.m_nDetailTint]->IsDefined() ) params[info.m_nDetailTint]->SetVecValue( 1.0f, 1.0f, 1.0f, 1.0f ); InitFloatParam( info.m_nDetailTextureBlendFactor, params, 1.0 ); InitIntParam( info.m_nDetailTextureCombineMode, params, 0 ); if( !params[info.m_nFresnelReflection]->IsDefined() ) params[info.m_nFresnelReflection]->SetFloatValue( 1.0f ); if( !params[info.m_nEnvmapMaskFrame]->IsDefined() ) params[info.m_nEnvmapMaskFrame]->SetIntValue( 0 ); if( !params[info.m_nEnvmapFrame]->IsDefined() ) params[info.m_nEnvmapFrame]->SetIntValue( 0 ); if( !params[info.m_nBumpFrame]->IsDefined() ) params[info.m_nBumpFrame]->SetIntValue( 0 ); if( !params[info.m_nDetailFrame]->IsDefined() ) params[info.m_nDetailFrame]->SetIntValue( 0 ); 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 ); InitFloatParam( info.m_nAlphaTestReference, params, 0.0f ); // No texture means no self-illum or env mask in base alpha if ( !params[info.m_nBaseTexture]->IsDefined() ) { CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); } if( params[info.m_nBumpmap]->IsDefined() ) { params[info.m_nEnvmapMask]->SetUndefined(); } // 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 ); if( g_pConfig->UseBumpmapping() && params[info.m_nBumpmap]->IsDefined() && (params[info.m_nNoDiffuseBumpLighting]->GetIntValue() == 0) ) { SET_FLAGS2( MATERIAL_VAR2_LIGHTING_BUMPED_LIGHTMAP ); } // If mat_specular 0, then get rid of envmap if( !g_pConfig->UseSpecular() && params[info.m_nEnvmap]->IsDefined() && params[info.m_nBaseTexture]->IsDefined() ) { params[info.m_nEnvmap]->SetUndefined(); } if( !params[info.m_nBaseTextureNoEnvmap]->IsDefined() ) { params[info.m_nBaseTextureNoEnvmap]->SetIntValue( 0 ); } if( !params[info.m_nBaseTexture2NoEnvmap]->IsDefined() ) { params[info.m_nBaseTexture2NoEnvmap]->SetIntValue( 0 ); } if( ( info.m_nSelfShadowedBumpFlag != -1 ) && ( !params[info.m_nSelfShadowedBumpFlag]->IsDefined() ) ) { params[info.m_nSelfShadowedBumpFlag]->SetIntValue( 0 ); } // handle line art parms InitFloatParam( info.m_nEdgeSoftnessStart, params, 0.5 ); InitFloatParam( info.m_nEdgeSoftnessEnd, params, 0.5 ); InitFloatParam( info.m_nOutlineAlpha, params, 1.0 ); // parallax mapping InitFloatParam( info.m_nHeightScale, params, 0.1 ); // srgb read 360 InitIntParam( info.m_nShaderSrgbRead360, params, 0 ); InitFloatParam( info.m_nEnvMapLightScale, params, 0.0f ); SET_PARAM_STRING_IF_NOT_DEFINED( info.m_nFoW, "_rt_fog_of_war" ); if ( g_pConfig->m_bPaintInGame ) { if( info.m_nPaintSplatNormal != -1 ) { if( !params[info.m_nPaintSplatNormal]->IsDefined() ) { params[info.m_nPaintSplatNormal]->SetStringValue( "paint/splatnormal_default" ); } } if( info.m_nPaintSplatEnvMap != -1 ) { if( !params[info.m_nPaintSplatEnvMap]->IsDefined() ) { if( params[info.m_nEnvmap]->IsDefined() ) { params[info.m_nPaintSplatEnvMap]->SetStringValue( params[info.m_nEnvmap]->GetStringValue() ); } else { params[info.m_nPaintSplatEnvMap]->SetStringValue( "env_cubemap" ); } } } } else { if( info.m_nPaintSplatNormal != -1 ) { params[info.m_nPaintSplatNormal]->SetUndefined(); } if( info.m_nPaintSplatEnvMap != -1 ) { params[info.m_nPaintSplatEnvMap]->SetUndefined(); } } }