void SetParameters(FRHICommandList& RHICmdList, const FViewInfo& View) { FGlobalShader::SetParameters(RHICmdList, GetVertexShader(),View); { // The fog can be set to start at a certain euclidean distance. // clamp the value to be behind the near plane z float FogStartDistance = FMath::Max(30.0f, View.ExponentialFogParameters.W); // Here we compute the nearest z value the fog can start // to render the quad at this z value with depth test enabled. // This means with a bigger distance specified more pixels are // are culled and don't need to be rendered. This is faster if // there is opaque content nearer than the computed z. FMatrix InvProjectionMatrix = View.ViewMatrices.GetInvProjMatrix(); FVector ViewSpaceCorner = InvProjectionMatrix.TransformFVector4(FVector4(1, 1, 1, 1)); float Ratio = ViewSpaceCorner.Z / ViewSpaceCorner.Size(); FVector ViewSpaceStartFogPoint(0.0f, 0.0f, FogStartDistance * Ratio); FVector4 ClipSpaceMaxDistance = View.ViewMatrices.ProjMatrix.TransformPosition(ViewSpaceStartFogPoint); float FogClipSpaceZ = ClipSpaceMaxDistance.Z / ClipSpaceMaxDistance.W; SetShaderValue(RHICmdList, GetVertexShader(),FogStartZ, FogClipSpaceZ); } }
// Adds a new vertex shader to the pass. // If a vertex shader already exists within the pass, it will be released. FCDEffectPassShader* FCDEffectPass::AddVertexShader() { FCDEffectPassShader* vertexShader; for (vertexShader = GetVertexShader(); vertexShader != NULL; vertexShader = GetVertexShader()) { SAFE_RELEASE(vertexShader); } vertexShader = AddShader(); vertexShader->AffectsVertices(); SetNewChildFlag(); return vertexShader; }
/** to have a similar interface as all other shaders */ void SetParameters(const FRenderingCompositePassContext& Context, FIntPoint TileCountValue, uint32 TileSize, float PixelKernelSize, float Threshold) { const FVertexShaderRHIParamRef ShaderRHI = GetVertexShader(); FGlobalShader::SetParameters(Context.RHICmdList, ShaderRHI, Context.View); PostprocessParameter.SetVS(ShaderRHI, Context, TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI()); { FIntRect TileCountAndSizeValue(TileCountValue, FIntPoint(TileSize, TileSize)); SetShaderValue(Context.RHICmdList, ShaderRHI, TileCountAndSize, TileCountAndSizeValue); } { // only approximate as the mip mapping doesn't produce accurate brightness scaling FVector4 ColorScaleValue(1.0f / FMath::Max(1.0f, PixelKernelSize * PixelKernelSize), Threshold, 0, 0); SetShaderValue(Context.RHICmdList, ShaderRHI, ColorScale, ColorScaleValue); } { FVector4 KernelSizeValue(PixelKernelSize, PixelKernelSize, 0, 0); SetShaderValue(Context.RHICmdList, ShaderRHI, KernelSize, KernelSizeValue); } }
const Ogre::MaterialPtr& MaterialGenerator::GetMaterial(Perm permutation) { // Check if material/shader permutation already was generated MaterialMap::iterator i = mMaterials.find(permutation); if (i != mMaterials.end()) { return i->second; } else { // Create it Ogre::MaterialPtr templ = GetTemplateMaterial(permutation & mMatMask); Ogre::GpuProgramPtr vs = GetVertexShader(permutation & mVsMask); Ogre::GpuProgramPtr fs = GetFragmentShader(permutation & mFsMask); // Create material name string name = mMaterialBaseName + Ogre::StringConverter::toString(permutation); // Create material from template, and set shaders Ogre::MaterialPtr mat = templ->clone(name); Ogre::Technique* tech = mat->getTechnique(0); Ogre::Pass* pass = tech->getPass(0); pass->setFragmentProgram(fs->getName()); pass->setVertexProgram(vs->getName()); // And store it mMaterials[permutation] = mat; return mMaterials[permutation]; } }
void SetParameters(const FRenderingCompositePassContext& Context) { const FVertexShaderRHIParamRef ShaderRHI = GetVertexShader(); const FSceneView& View = Context.View; FGlobalShader::SetParameters(Context.RHICmdList, ShaderRHI, Context.View); PostprocessParameter.SetVS(ShaderRHI, Context, TStaticSamplerState<SF_Bilinear,AM_Clamp,AM_Clamp,AM_Clamp>::GetRHI()); const FPooledRenderTargetDesc* InputDesc = Context.Pass->GetInputDesc(ePId_Input0); if(!InputDesc) { // input is not hooked up correctly return; } { // from percent to fraction float Offset = View.FinalPostProcessSettings.SceneFringeIntensity * 0.01f; // we only get bigger to not leak in content from outside FVector4 Value(1.0f, 1.0f - Offset * 0.5f, 1.0f - Offset, 0); SetShaderValue(Context.RHICmdList, ShaderRHI, FringeUVParams, Value); } }
void SetParameters(FRHICommandList& RHICmdList, const FSceneView& View, const FMatrix& InFrustumComponentToClip) { const FVertexShaderRHIParamRef ShaderRHI = GetVertexShader(); FGlobalShader::SetParameters(RHICmdList, ShaderRHI, View); SetShaderValue(RHICmdList, ShaderRHI, FrustumComponentToClip, InFrustumComponentToClip); }
void SetParameters( FRHICommandList& RHICmdList, const FSceneView& View ) { FVertexShaderRHIParamRef ShaderRHI = GetVertexShader(); FGlobalShader::SetParameters(RHICmdList, ShaderRHI, View); }
/** to have a similar interface as all other shaders */ void SetParameters(const FRenderingCompositePassContext& Context, FIntPoint TileCountValue) { const FVertexShaderRHIParamRef ShaderRHI = GetVertexShader(); FGlobalShader::SetParameters(Context.RHICmdList, ShaderRHI, Context.View); PostprocessParameter.SetVS(ShaderRHI, Context, TStaticSamplerState<SF_Point,AM_Clamp,AM_Clamp,AM_Clamp>::GetRHI()); SetShaderValue(Context.RHICmdList, ShaderRHI, TileCount, TileCountValue); }
/** * Sets parameters for particle injection. */ void SetParameters(FRHICommandList& RHICmdList, const FVector2D& CurveOffset ) { FParticleCurveInjectionParameters Parameters; Parameters.PixelScale.X = 1.0f / GParticleCurveTextureSizeX; Parameters.PixelScale.Y = 1.0f / GParticleCurveTextureSizeY; Parameters.CurveOffset = CurveOffset; FParticleCurveInjectionBufferRef UniformBuffer = FParticleCurveInjectionBufferRef::CreateUniformBufferImmediate( Parameters, UniformBuffer_SingleDraw ); FVertexShaderRHIParamRef VertexShader = GetVertexShader(); SetUniformBufferParameter(RHICmdList, VertexShader, GetUniformBufferParameter<FParticleCurveInjectionParameters>(), UniformBuffer ); }
// Retrieve specified vertex shader //----------------------------------------------------------------------------- CPUTResult CPUTAssetLibraryOGL::GetVertexShader( const cString &name, const cString &shaderMain, const cString &shaderProfile, CPUTShaderOGL **ppVertexShader, bool nameIsFullPathAndFilename, CPUT_SHADER_MACRO *pShaderMacros ) { std::vector<cString> filenames; filenames.push_back(name); return GetVertexShader(filenames, shaderMain, shaderProfile, ppVertexShader, nameIsFullPathAndFilename, pShaderMacros); }
void SetParameters(const FRenderingCompositePassContext& Context) { const FVertexShaderRHIParamRef ShaderRHI = GetVertexShader(); FGlobalShader::SetParameters(Context.RHICmdList, ShaderRHI, Context.View); const FPooledRenderTargetDesc* InputDesc = Context.Pass->GetInputDesc(ePId_Input0); if(!InputDesc) { // input is not hooked up correctly return; } }
void SetParameters( const FSceneView* View, const FLightSceneInfo* LightSceneInfo ) { FMaterialShader::SetParameters(GetVertexShader(), *View); // Light functions are projected using a bounding sphere. // Calculate transform for bounding stencil sphere. FSphere LightBounds = LightSceneInfo->Proxy->GetBoundingSphere(); if (LightSceneInfo->Proxy->GetLightType() == LightType_Directional) { LightBounds.Center = View->ViewMatrices.ViewOrigin; } FVector4 StencilingSpherePosAndScale; StencilingGeometry::CalcTransform(StencilingSpherePosAndScale, LightBounds, View->ViewMatrices.PreViewTranslation); StencilingGeometryParameters.Set(this, StencilingSpherePosAndScale); }
void SetParameters(const FRenderingCompositePassContext& Context) { const FVertexShaderRHIParamRef ShaderRHI = GetVertexShader(); FGlobalShader::SetParameters(Context.RHICmdList, ShaderRHI, Context.View); const FPooledRenderTargetDesc* InputDesc = Context.Pass->GetInputDesc(ePId_Input0); if(!InputDesc) { // input is not hooked up correctly return; } FVector2D InvExtent = FVector2D(1.0f / InputDesc->Extent.X, 1.0f / InputDesc->Extent.Y); SetShaderValue(Context.RHICmdList, ShaderRHI, fxaaQualityRcpFrame, InvExtent); }
void SetParameters(const FRenderingCompositePassContext& Context, const FRCPassPostProcessUpscale::PaniniParams& InPaniniConfig) { const FVertexShaderRHIParamRef ShaderRHI = GetVertexShader(); FGlobalShader::SetParameters(Context.RHICmdList, ShaderRHI, Context.View); { const FVector2D FOVPerAxis = Context.View.ViewMatrices.GetFieldOfViewPerAxis(); const FVector2D ScreenPosToPaniniFactor = FVector2D(FMath::Tan(FOVPerAxis.X), FMath::Tan(FOVPerAxis.Y)); const FVector2D PaniniDirection = FVector2D(1.0f, 0.0f) * ScreenPosToPaniniFactor; const FVector2D PaniniPosition = PaniniProjection(PaniniDirection, InPaniniConfig.D, InPaniniConfig.S); const float WidthFit = ScreenPosToPaniniFactor.X / PaniniPosition.X; const float OutScreenPosScale = FMath::Lerp(1.0f, WidthFit, InPaniniConfig.ScreenFit); FVector Value(InPaniniConfig.D, InPaniniConfig.S, OutScreenPosScale); SetShaderValue(Context.RHICmdList, ShaderRHI, PaniniParameters, Value); } }
void Shader::LinkProgram() { p = glCreateProgramObjectARB(); for ( std::vector< std::string >::iterator it = vertexes.begin(), it2 = vertexes.end(); it != it2; ++it ) { int s = GetVertexShader( *it ); glAttachObjectARB( p, s ); } for ( std::vector< std::string >::iterator it = fragments.begin(), it2 = fragments.end(); it != it2; ++it ) { int s = GetFragmentShader( *it ); glAttachObjectARB( p, s ); } glLinkProgramARB( p ); BindProgram(); }
void SetVS(const FRenderingCompositePassContext& Context) { const FVertexShaderRHIParamRef ShaderRHI = GetVertexShader(); FGlobalShader::SetParameters(Context.RHICmdList, ShaderRHI, Context.View); PostprocessParameter.SetVS(ShaderRHI, Context, TStaticSamplerState<SF_Bilinear,AM_Clamp,AM_Clamp,AM_Clamp>::GetRHI()); if(EyeAdaptation.IsBound()) { if (Context.View.HasValidEyeAdaptation()) { IPooledRenderTarget* EyeAdaptationRT = Context.View.GetEyeAdaptation(Context.RHICmdList); SetTextureParameter(Context.RHICmdList, ShaderRHI, EyeAdaptation, EyeAdaptationRT->GetRenderTargetItem().TargetableTexture); } else { SetTextureParameter(Context.RHICmdList, ShaderRHI, EyeAdaptation, GWhiteTexture->TextureRHI); } } }
void SetVS(const FRenderingCompositePassContext& Context, EStereoscopicPass StereoPass) { const FVertexShaderRHIParamRef ShaderRHI = GetVertexShader(); FGlobalShader::SetParameters(Context.RHICmdList, ShaderRHI, Context.View); check(GEngine->HMDDevice.IsValid()); FVector2D EyeToSrcUVScaleValue; FVector2D EyeToSrcUVOffsetValue; GEngine->HMDDevice->GetEyeRenderParams_RenderThread(StereoPass, EyeToSrcUVScaleValue, EyeToSrcUVOffsetValue); SetShaderValue(Context.RHICmdList, ShaderRHI, EyeToSrcUVScale, EyeToSrcUVScaleValue); SetShaderValue(Context.RHICmdList, ShaderRHI, EyeToSrcUVOffset, EyeToSrcUVOffsetValue); if (bTimeWarp) { FMatrix startM, endM; GEngine->HMDDevice->GetTimewarpMatrices_RenderThread(StereoPass, startM, endM); SetShaderValue(Context.RHICmdList, ShaderRHI, EyeRotationStart, startM); SetShaderValue(Context.RHICmdList, ShaderRHI, EyeRotationEnd, endM); } }
void plLayer::Write(hsStream* s, hsResMgr* mgr) { plLayerInterface::Write(s, mgr); fState->Write(s); fTransform->Write(s); fPreshadeColor->Write(s); fRuntimeColor->Write( s ); fAmbientColor->Write(s); fSpecularColor->Write( s ); s->WriteLE32(*fUVWSrc); s->WriteLEScalar(*fOpacity); s->WriteLEScalar(*fLODBias); s->WriteLEScalar(*fSpecularPower); mgr->WriteKey(s, GetTexture()); mgr->WriteKey(s, GetVertexShader()); mgr->WriteKey(s, GetPixelShader()); fBumpEnvXfm->Write(s); }
HRESULT myIDirect3DDevice9::DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount) { if (isThisSky && GetKeyState(VK_F3)) { DebugBreak(); } if (isThisBarrel) { IDirect3DVertexDeclaration9* vDecl; GetVertexDeclaration(&vDecl); IDirect3DVertexShader9* vShader; GetVertexShader(&vShader); DB_EnumXAssets(ASSET_TYPE_VERTEXDECL, DebugVertexDecl, (int)vDecl); DB_EnumXAssets(ASSET_TYPE_VERTEXSHADER, DebugVertexShader, (int)vShader); __asm int 3 isThisBarrel = false; } return(m_pIDirect3DDevice9->DrawIndexedPrimitive(PrimitiveType,BaseVertexIndex,MinVertexIndex,NumVertices,startIndex,primCount)); }
/** Sets shader parameter values */ void SetParameters(FRHICommandList& RHICmdList, const FViewInfo& View) { FGlobalShader::SetParameters(RHICmdList, GetVertexShader(), View); }
void SetParameters(const FSceneView& View) { const FVertexShaderRHIParamRef ShaderRHI = GetVertexShader(); FGlobalShader::SetParameters(ShaderRHI, View); }
void SetParameters(const FMaterialRenderProxy* MaterialRenderProxy,const FMaterial& MaterialResource,const FSceneView& View) { FMeshMaterialShader::SetParameters(GetVertexShader(),MaterialRenderProxy,MaterialResource,View,ESceneRenderTargetsMode::DontSet); }
void SetMesh(FRHICommandList& RHICmdList, const FVertexFactory* VertexFactory,const FSceneView& View,const FPrimitiveSceneProxy* Proxy,const FMeshBatchElement& BatchElement, float DitheredLODTransitionValue) { FMeshMaterialShader::SetMesh(RHICmdList, GetVertexShader(),VertexFactory,View,Proxy,BatchElement,DitheredLODTransitionValue); }
void SetParameters(FRHICommandList& RHICmdList, const FVertexFactory* VertexFactory,const FMaterialRenderProxy* MaterialRenderProxy,const FSceneView* View) { FMeshMaterialShader::SetParameters(RHICmdList, GetVertexShader(), MaterialRenderProxy, *MaterialRenderProxy->GetMaterial(View->GetFeatureLevel()), *View, ESceneRenderTargetsMode::SetTextures); }
bool GLVideo::DrawRectangle( const math::Vector2 &v2Pos, const math::Vector2 &v2Size, const Color& color0, const Color& color1, const Color& color2, const Color& color3, const float angle, const Sprite::ENTITY_ORIGIN origin) { if (v2Size == math::Vector2(0,0)) { return true; } // TODO/TO-DO this is diplicated code: fix it math::Vector2 v2Center; switch (origin) { case Sprite::EO_CENTER: case Sprite::EO_RECT_CENTER: v2Center.x = v2Size.x / 2.0f; v2Center.y = v2Size.y / 2.0f; break; case Sprite::EO_RECT_CENTER_BOTTOM: case Sprite::EO_CENTER_BOTTOM: v2Center.x = v2Size.x / 2.0f; v2Center.y = v2Size.y; break; case Sprite::EO_RECT_CENTER_TOP: case Sprite::EO_CENTER_TOP: v2Center.x = v2Size.x / 2.0f; v2Center.y = 0.0f; break; case Sprite::EO_DEFAULT: default: v2Center.x = 0.0f; v2Center.y = 0.0f; break; }; math::Matrix4x4 mRot; if (angle != 0.0f) mRot = math::RotateZ(math::DegreeToRadian(angle)); m_rectVS->SetMatrixConstant("rotationMatrix", mRot); m_rectVS->SetConstant("size", v2Size); m_rectVS->SetConstant("entityPos", v2Pos); m_rectVS->SetConstant("center", v2Center); m_rectVS->SetConstant("color0", color0); m_rectVS->SetConstant("color1", color1); m_rectVS->SetConstant("color2", color2); m_rectVS->SetConstant("color3", color3); ShaderPtr prevVertexShader = GetVertexShader(), prevPixelShader = GetPixelShader(); SetVertexShader(m_rectVS); SetPixelShader(ShaderPtr()); UnsetTexture(0); UnsetTexture(1); GetVertexShader()->SetShader(); m_rectRenderer.Draw(Sprite::RM_TWO_TRIANGLES); SetPixelShader(prevPixelShader); SetVertexShader(prevVertexShader); return true; }
void FSimpleElementVS::SetParameters(const FMatrix& TransformValue, bool bSwitchVerticalAxis) { SetShaderValue(GetVertexShader(),Transform,TransformValue); SetShaderValue(GetVertexShader(),SwitchVerticalAxis, bSwitchVerticalAxis ? -1.0f : 1.0f); }
void FCubemapTexturePropertiesVS::SetParameters( FRHICommandList& RHICmdList, const FMatrix& TransformValue ) { SetShaderValue(RHICmdList, GetVertexShader(), Transform, TransformValue); }
void RotationManipulator::RenderScaled(const Vect &cameraDir, float scale) { traceInFast(RotationManipulator::RenderScaled); DWORD i; Shader *rotManipShader = GetVertexShader(TEXT("Editor:RotationManipulator.vShader")); LoadVertexShader(rotManipShader); LoadPixelShader(GetPixelShader(TEXT("Base:SolidColor.pShader"))); rotManipShader->SetVector(rotManipShader->GetParameter(2), cameraDir); MatrixPush(); MatrixTranslate(GetWorldPos()); MatrixScale(scale, scale, scale); for(i=0; i<3; i++) { Vect axisColor(0.0f, 0.0f, 0.0f); axisColor.ptr[i] = 1.0f; if(i == activeAxis) axisColor.Set(1.0f, 1.0f, 0.0f); else axisColor.ptr[i] = 1.0f; rotManipShader->SetVector(rotManipShader->GetParameter(1), axisColor); LoadVertexBuffer(axisBuffers[i]); LoadIndexBuffer(NULL); Draw(GS_LINESTRIP); } LoadVertexBuffer(NULL); //---------------------------------------------------- Shader *solidShader = GetVertexShader(TEXT("Base:SolidColor.vShader")); LoadVertexShader(solidShader); MatrixPush(); MatrixRotate(Quat().SetLookDirection(cameraDir)); LoadVertexBuffer(axisBuffers[2]); LoadIndexBuffer(NULL); solidShader->SetColor(solidShader->GetParameter(1), 0.5, 0.5, 0.5, 0.5); Draw(GS_LINESTRIP); MatrixScale(1.25f, 1.25f, 1.25f); //--------------- if(activeAxis == 4) solidShader->SetColor(solidShader->GetParameter(1), 1.0f, 1.0f, 0.0, 1.0f); else solidShader->SetColor(solidShader->GetParameter(1), 0.8, 0.8, 0.8, 0.8); Draw(GS_LINESTRIP); MatrixPop(); MatrixPop(); LoadVertexShader(NULL); LoadPixelShader(NULL); traceOutFast; }
void SetMesh(FRHICommandList& RHICmdList, const FVertexFactory* VertexFactory,const FSceneView& View,const FPrimitiveSceneProxy* Proxy,const FMeshBatchElement& BatchElement) { FMeshMaterialShader::SetMesh(RHICmdList, GetVertexShader(),VertexFactory,View,Proxy,BatchElement); }
void SetMesh(FRHICommandList& RHICmdList, const FVertexFactory* VertexFactory, const FMeshBatch& Mesh, int32 BatchElementIndex, const FViewInfo& View, const FPrimitiveSceneProxy* Proxy, const FMatrix& InPreviousLocalToWorld) { FMeshMaterialShader::SetMesh(RHICmdList, GetVertexShader(), VertexFactory, View, Proxy, Mesh.Elements[BatchElementIndex]); SetShaderValue(RHICmdList, GetVertexShader(), PreviousLocalToWorld, InPreviousLocalToWorld.ConcatTranslation(View.PrevViewMatrices.PreViewTranslation)); }