public GetTechnique ( int index ) : |
||
index | int | Index of the technique to return. |
return |
/// <summary> /// Helper function to set the texture coordinates. Instead of taking a movie /// object, this takes a specific texture name, video size, texture size, and /// material. Sets a texture matrix to adjust the existing coordinates. /// </summary> /// <param name="textureName"> /// The name of the texture to adjust. /// </param> /// <param name="videoSize"> /// The size of the video in pixels. /// </param> /// <param name="textureSize"> /// The size of the expected texture in pixels. /// </param> /// <param name="material"> /// The name of the material to search for textures. /// </param> /// <returns> /// True if any texture coordinates were adjusted, false if not. /// </returns> public static bool SetTextureCoordinates(string textureName, Size videoSize, Size textureSize, string material) { bool ans = false; Axiom.Graphics.Material m = MaterialManager.Instance.GetByName(material); if (m != null) { for (int i = 0; i < m.NumTechniques; i++) { for (int j = 0; j < m.GetTechnique(i).NumPasses; j++) { Pass p = m.GetTechnique(i).GetPass(j); for (int k = 0; k < p.NumTextureUnitStages; k++) { if (p.GetTextureUnitState(k).TextureName == textureName) { TextureUnitState tu = p.GetTextureUnitState(k); float uRatio = ((float)videoSize.Width) / ((float)textureSize.Width); float vRatio = ((float)videoSize.Height) / ((float)textureSize.Height); tu.SetTextureScale(1.0f / uRatio, 1.0f / vRatio); tu.SetTextureScroll(-0.5f * (1.0f - uRatio), -0.5f * (1.0f - vRatio)); ans = true; } } } } } return(ans); }
public void CameraDataUpdate(InteropBitmap cameraInterop) { // Stores the cam input as bitmap source var imageSource = cameraInterop as BitmapSource; // Creates an jpeg encoder BitmapEncoder enc = new JpegBitmapEncoder(); // Create bitmap frame from the image source enc.Frames.Add(BitmapFrame.Create(imageSource)); // Saves the frame to a memory stream var ms = new MemoryStream(); enc.Save(ms); // Create a bitmap from the memory stream var bitmap = new Bitmap(ms); // Get width and height int width = bitmap.Width; int height = bitmap.Height; // Gets the buffer from the texture var texBuffer = m_texture.GetBuffer(); // Locks the buffer so we can copy data into the buffer texBuffer.Lock(BufferLocking.Discard); PixelBox pb = texBuffer.CurrentLock; BitmapData data = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); // Copy the data into the buffer CopyMemory(pb.Data, data.Scan0, (uint)((width) * height * 4)); // Unlock the buffer bitmap.UnlockBits(data); texBuffer.Unlock(); // Render using the material m_axiomMaterial.GetTechnique(0).GetPass(0).RemoveAllTextureUnitStates(); m_axiomMaterial.GetTechnique(0).GetPass(0).CreateTextureUnitState("DynamicTexture"); // Update the camera orientation UpdateCameraOrientation(); try { // Render a single frame m_root.RenderOneFrame(); } catch (Exception e) { return; } }
public RSQuadOperation(CompositorInstance instance, uint pass_id, Material mat) { this.mat = mat; this.instance = instance; this.pass_id = pass_id; mat.Load(); instance.FireNotifyMaterialSetup(pass_id, mat); technique = mat.GetTechnique(0); Debug.Assert(technique != null); }
public BspGeometry() { geometryMat = MaterialManager.Instance.GetByName("Axiom/BspGeometryMaterial"); if (geometryMat == null) { geometryMat = (Material) MaterialManager.Instance.Create("Axiom/BspGeometryMaterial"); geometryMat.ReceiveShadows = true; technique = geometryMat.GetTechnique(0); } }
///<summary> /// Create a local dummy material with one technique but no passes. /// The material is detached from the Material Manager to make sure it is destroyed /// when going out of scope. ///</summary> protected Material CreateLocalMaterial() { Material mat = (Material)MaterialManager.Instance.Create("CompositorInstanceMaterial" + materialDummyCounter); ++materialDummyCounter; // Ogre removed it from the resource list, but no such API exists in // in Axiom. MaterialManager.Instance.Unload(mat); /// Remove all passes from first technique mat.GetTechnique(0).RemoveAllPasses(); return(mat); }
/// <summary> /// Helper function to replace an entity in the scene. Adjusts the /// texture coordinates to flip the video. That may be wrong on /// everything except DirectX / DirectShow. /// </summary> /// <param name="en"> /// The entity we're going to replace. /// </param> /// <param name="meshName"> /// The name of the mesh to create. /// </param> /// <param name="materialName"> /// The name of the material to create. /// </param> /// <param name="textureName"> /// The name of the texture to create. /// </param> /// <param name="videoSize"> /// The size of the movie, in width by height pixels. /// </param> /// <param name="textureSize"> /// The size of the texture, in width by height pixels. /// </param> /// <returns></returns> private static bool ReplaceEntity( Entity en, string meshName, string materialName, string textureName, Size videoSize, Size textureSize) { Mesh me = MeshManager.Instance.CreatePlane( meshName, // name new Axiom.MathLib.Plane(new Axiom.MathLib.Vector3(0, 0, -1), new Axiom.MathLib.Vector3(0, 0, 0)), videoSize.Width, videoSize.Height, 1, // xsegments 1, // ysegments true, // normals 1, // numtexcoords 1.0f, // utile 1.0f, // vtile new Axiom.MathLib.Vector3(0, 1, 0) // upvec ); en.Mesh = me; Axiom.Graphics.Material m = MaterialManager.Instance.GetByName(materialName); if (m == null) { m = (Axiom.Graphics.Material) MaterialManager.Instance.Create(materialName, true); ColorEx c = new ColorEx(1.0f, 1.0f, 1.0f); m.Ambient = c; m.Diffuse = c; for (int i = 0; i < m.GetTechnique(0).NumPasses; i++) { Pass p = m.GetTechnique(0).GetPass(i); p.RemoveAllTextureUnitStates(); p.CreateTextureUnitState(textureName); } } en.MaterialName = materialName; return(true); }
/// <summary> /// /// </summary> /// <param name="prof"></param> /// <param name="mat"></param> /// <param name="terrain"></param> /// <param name="compositeMap"></param> public virtual void UpdateParams( SM2Profile prof, Material mat, Terrain terrain, bool compositeMap ) { Pass p = mat.GetTechnique( 0 ).GetPass( 0 ); if ( compositeMap ) { UpdateVpParams( prof, terrain, TechniqueType.RenderCompositeMap, p.VertexProgramParameters ); UpdateFpParams( prof, terrain, TechniqueType.RenderCompositeMap, p.FragmentProgramParameters ); } else { //high lod UpdateVpParams( prof, terrain, TechniqueType.HighLod, p.VertexProgramParameters ); UpdateFpParams( prof, terrain, TechniqueType.HighLod, p.FragmentProgramParameters ); //low lod p = mat.GetTechnique( 1 ).GetPass( 0 ); UpdateVpParams( prof, terrain, TechniqueType.LowLod, p.VertexProgramParameters ); UpdateFpParams( prof, terrain, TechniqueType.LowLod, p.FragmentProgramParameters ); } }
public void UpdateMaterial(Material material) { if (useParams) { Pass pass = material.GetTechnique(0).GetPass(0); pass.GetTextureUnitState(0).SetTextureName(sandTextureName); pass.GetTextureUnitState(1).SetTextureName(grassTextureName); pass.GetTextureUnitState(2).SetTextureName(rockTextureName); pass.GetTextureUnitState(3).SetTextureName(snowTextureName); GpuProgramParameters vertexParams = pass.VertexProgramParameters; vertexParams.SetNamedConstant("splatConfig", new Vector3(sandToGrassHeight, grassToRockHeight, rockToSnowHeight)); vertexParams.SetNamedConstant("textureTileSize", new Vector3(textureTileSize, 0, 0)); if (useGeneratedShadeMask) { Page.SetShadeMask(material, 4); } else { pass.GetTextureUnitState(4).SetTextureName(shadeMaskTextureName); } } }
private TextureUnitState LoadMaterialTextures(int p, int lightmapNumber, Material material) { TextureUnitState t; if(pass[p].textureName == "$lightmap") { string lightmapName = String.Format("@lightmap{0}", lightmapNumber); t = material.GetTechnique(0).GetPass(0).CreateTextureUnitState(lightmapName); } // Animated texture support else if(pass[p].animNumFrames > 0) { float sequenceTime = pass[p].animNumFrames / pass[p].animFps; /* Pre-load textures We need to know if each one was loaded OK since extensions may change for each Quake3 can still include alternate extension filenames e.g. jpg instead of tga Pain in the arse - have to check for each frame as letters<n>.tga for example is different per frame! */ for(uint alt = 0; alt < pass[p].animNumFrames; ++alt) { try { TextureManager.Instance.Load(pass[p].frames[alt]); } catch { // Try alternate extension pass[p].frames[alt] = GetAlternateName(pass[p].frames[alt]); try { TextureManager.Instance.Load(pass[p].frames[alt]); } catch { // stuffed - no texture } } } t = material.GetTechnique(0).GetPass(0).CreateTextureUnitState(""); t.SetAnimatedTextureName(pass[p].frames, pass[p].animNumFrames, sequenceTime); if(t.IsBlank) { for(int alt = 0; alt < pass[p].animNumFrames; alt++) pass[p].frames[alt] = GetAlternateName(pass[p].frames[alt]); t.SetAnimatedTextureName(pass[p].frames, pass[p].animNumFrames, sequenceTime); } } else { // Quake3 can still include alternate extension filenames e.g. jpg instead of tga // Pain in the arse - have to check for failure try { TextureManager.Instance.Load(pass[p].textureName); } catch { // Try alternate extension pass[p].textureName = GetAlternateName(pass[p].textureName); try { TextureManager.Instance.Load(pass[p].textureName); } catch { // stuffed - no texture } } t = material.GetTechnique(0).GetPass(0).CreateTextureUnitState(pass[p].textureName); } return t; }
public static void SetShadeMask(Material mat, int texunit) { if (shadeMask == null) { BuildShadeMask(); } mat.GetTechnique(0).GetPass(0).GetTextureUnitState(texunit).SetTextureName(shadeMask.Name); }
public override void LoadWorldGeometry(string fileName) { TerrainOptions options = new TerrainOptions(); DataSet optionData = new DataSet(); optionData.ReadXml(fileName); DataTable table = optionData.Tables[0]; DataRow row = table.Rows[0]; string terrainFileName = ""; string detailTexture = ""; string worldTexture = ""; if(table.Columns["Terrain"] != null) { terrainFileName = (string)row["Terrain"]; } if(table.Columns["DetailTexture"] != null) { detailTexture = (string)row["DetailTexture"]; } if(table.Columns["WorldTexture"] != null) { worldTexture = (string)row["WorldTexture"]; } if(table.Columns["MaxMipMapLevel"] != null) { options.maxMipmap = Convert.ToInt32(row["MaxMipMapLevel"]); } if(table.Columns["DetailTile"] != null) { options.detailTile = Convert.ToInt32(row["DetailTile"]); } if(table.Columns["MaxPixelError"] != null) { options.maxPixelError = Convert.ToInt32(row["MaxPixelError"]); } if(table.Columns["TileSize"] != null) { options.size = Convert.ToInt32(row["TileSize"]); } if(table.Columns["ScaleX"] != null) { options.scalex = StringConverter.ParseFloat((string)row["ScaleX"]); } if(table.Columns["ScaleY"] != null) { options.scaley = StringConverter.ParseFloat((string)row["ScaleY"]); } if(table.Columns["ScaleZ"] != null) { options.scalez = StringConverter.ParseFloat((string)row["ScaleZ"]); } if(table.Columns["VertexNormals"] != null) { options.isLit = ((string)row["VertexNormals"]) == "yes" ? true : false; } scale = new Vector3(options.scalex, options.scaley, options.scalez); tileSize = options.size; // load the heightmap Image image = Image.FromFile(terrainFileName); // TODO: Check terrain size for 2^n + 1 // get the data from the heightmap options.data = image.Data; options.worldSize = image.Width; float maxx = options.scalex * options.worldSize; float maxy = 255 * options.scaley; float maxz = options.scalez * options.worldSize; Resize(new AxisAlignedBox(Vector3.Zero, new Vector3(maxx, maxy, maxz))); terrainMaterial = CreateMaterial("Terrain"); if(worldTexture != "") { terrainMaterial.GetTechnique(0).GetPass(0).CreateTextureUnitState(worldTexture, 0); } if(detailTexture != "") { terrainMaterial.GetTechnique(0).GetPass(0).CreateTextureUnitState(detailTexture, 1); } terrainMaterial.Lighting = options.isLit; terrainMaterial.Load(); terrainRoot = (SceneNode)RootSceneNode.CreateChild("TerrainRoot"); numTiles = (options.worldSize - 1) / (options.size - 1); tiles = new TerrainRenderable[numTiles, numTiles]; int p = 0, q = 0; for(int j = 0; j < options.worldSize - 1; j += (options.size - 1)) { p = 0; for(int i = 0; i < options.worldSize - 1; i += (options.size - 1)) { options.startx = i; options.startz = j; string name = string.Format("Tile[{0},{1}]", p, q); SceneNode node = (SceneNode)terrainRoot.CreateChild(name); TerrainRenderable tile = new TerrainRenderable(); tile.Name = name; tile.SetMaterial(terrainMaterial); tile.Init(options); tiles[p,q] = tile; node.AttachObject(tile); p++; } q++; } int size1 = tiles.GetLength(0); int size2 = tiles.GetLength(1); for(int j = 0; j < size1; j++) { for(int i = 0; i < size2; i++) { if(j != size1 - 1) { ((TerrainRenderable)tiles[i,j]).SetNeighbor(Neighbor.South, (TerrainRenderable)tiles[i, j + 1]); ((TerrainRenderable)tiles[i,j + 1]).SetNeighbor(Neighbor.North, (TerrainRenderable)tiles[i, j]); } if(i != size2 - 1) { ((TerrainRenderable)tiles[i,j]).SetNeighbor(Neighbor.East, (TerrainRenderable)tiles[i + 1, j]); ((TerrainRenderable)tiles[i + 1,j]).SetNeighbor(Neighbor.West, (TerrainRenderable)tiles[i, j]); } } } #if NOT_USED if(false) // && options.isLit) //TODO: Fix { for(int j = 0; j < size1; j++) { for(int i = 0; i < size2; i++) { ((TerrainRenderable)tiles[i,j]).CalculateNormals(); } } } #endif this.terrainOptions = options; //we need these later for GetHeightAt, so make them a member variable }
public RSQuadOperation(CompositorInstance instance, uint pass_id, Material mat) { this.mat = mat; this.instance = instance; this.pass_id = pass_id; mat.Load(); instance.FireNotifyMaterialSetup(pass_id, mat); technique = mat.GetTechnique(0); Debug.Assert(technique != null); }
/* * System::Void JointPositionOverlay::copyBitmapToTexture() { // Lock the texture buffer so we can write to it Ogre::HardwarePixelBufferSharedPtr buffer = mTexture->getBuffer (); buffer->lock(Ogre::HardwareBuffer::HBL_DISCARD); const Ogre::PixelBox &pb = buffer->getCurrentLock(); Ogre::uint32 *texData = static_cast<Ogre::uint32*>(pb.data); // Lock the bitmap buffer so we can read from it System::Drawing::Imaging::BitmapData^ bmd = mBitmap->LockBits( System::Drawing::Rectangle(0, 0, mBitmap->Width, mBitmap->Height), System::Drawing::Imaging::ImageLockMode::ReadOnly, System::Drawing::Imaging::PixelFormat::Format32bppArgb); Ogre::uint32* mapData = static_cast<Ogre::uint32*>(bmd->Scan0.ToPointer()); // Now copy the data between buffers size_t height = std::min (pb.getHeight(), (size_t)bmd->Height); size_t width = std::min(pb.getWidth(), (size_t)bmd->Width); for(size_t y=0; y<height; ++y) for(size_t x=0; x<width; ++x) texData[pb.rowPitch*y + x] = mapData[bmd->Stride/4 * y + x]; // Unlock the buffers again mBitmap->UnlockBits(bmd); buffer->unlock(); } * * * */ /// <summary> /// Creates the dynamic texture and material. /// </summary> /// <param name="TextureName">Name of the texture.</param> /// <param name="MaterialName">Name of the material.</param> /// <param name="textureHeight">Height of the texture.</param> /// <param name="textureWidth">Width of the texture.</param> /// <param name="texture">The texture.</param> /// <param name="material">The material.</param> public static void CreateDynamicTextureAndMaterial(string TextureName, string MaterialName, int textureWidth, int textureHeight, out Texture texture, out Material material) { texture = TextureManager.Instance.CreateManual(TextureName, ResourceGroupManager.DefaultResourceGroupName, TextureType.TwoD, textureWidth, textureHeight, 0, Axiom.Media.PixelFormat.A8R8G8B8, TextureUsage.DynamicWriteOnlyDiscardable); material = (Material)MaterialManager.Instance.Create(MaterialName, ResourceGroupManager.DefaultResourceGroupName); material.GetTechnique(0).GetPass(0).CreateTextureUnitState(TextureName); }
///<summary> /// Collect rendering passes. Here, passes are converted into render target operations /// and queued with queueRenderSystemOp. ///</summary> protected void CollectPasses(CompositorTargetOperation finalState, CompositionTargetPass target) { /// Here, passes are converted into render target operations Pass targetpass; Technique srctech; Material srcmat; foreach (CompositionPass pass in target.Passes) { switch (pass.Type) { case CompositorPassType.Clear: QueueRenderSystemOp(finalState, new RSClearOperation( pass.ClearBuffers, pass.ClearColor, pass.ClearDepth, pass.ClearStencil)); break; case CompositorPassType.Stencil: QueueRenderSystemOp(finalState, new RSStencilOperation( pass.StencilCheck, pass.StencilFunc, pass.StencilRefValue, pass.StencilMask, pass.StencilFailOp, pass.StencilDepthFailOp, pass.StencilPassOp, pass.StencilTwoSidedOperation )); break; case CompositorPassType.RenderScene: if ((int)pass.FirstRenderQueue < (int)finalState.CurrentQueueGroupID) { /// Mismatch -- warn user /// XXX We could support repeating the last queue, with some effort LogManager.Instance.Write("Warning in compilation of Compositor " + compositor.Name + ": Attempt to render queue " + pass.FirstRenderQueue + " before " + finalState.CurrentQueueGroupID); } /// Add render queues for (RenderQueueGroupID x = pass.FirstRenderQueue; x <= pass.LastRenderQueue; ++x) { Debug.Assert(x >= 0); finalState.RenderQueues[(int)x] = true; } finalState.CurrentQueueGroupID = (RenderQueueGroupID)((int)pass.LastRenderQueue + 1); finalState.FindVisibleObjects = true; finalState.MaterialScheme = target.MaterialScheme; break; case CompositorPassType.RenderQuad: srcmat = pass.Material; if (srcmat == null) { /// No material -- warn user LogManager.Instance.Write("Warning in compilation of Compositor " + compositor.Name + ": No material defined for composition pass"); break; } srcmat.Load(); if (srcmat.SupportedTechniques.Count == 0) { /// No supported techniques -- warn user LogManager.Instance.Write("Warning in compilation of Compositor " + compositor.Name + ": material " + srcmat.Name + " has no supported techniques"); break; } srctech = srcmat.GetBestTechnique(0); /// Create local material Material localMat = CreateLocalMaterial(); /// Copy and adapt passes from source material for (int i = 0; i < srctech.NumPasses; i++) { Pass srcpass = srctech.GetPass(i); /// Create new target pass targetpass = localMat.GetTechnique(0).CreatePass(); srcpass.CopyTo(targetpass); /// Set up inputs int numInputs = pass.GetNumInputs(); for (int x = 0; x < numInputs; x++) { string inp = pass.Inputs[x]; if (inp != string.Empty) { if (x < targetpass.NumTextureUnitStages) { targetpass.GetTextureUnitState(x).SetTextureName(GetSourceForTex(inp)); } else { /// Texture unit not there LogManager.Instance.Write("Warning in compilation of Compositor " + compositor.Name + ": material " + srcmat.Name + " texture unit " + x + " out of bounds"); } } } } QueueRenderSystemOp(finalState, new RSQuadOperation(this, pass.Identifier, localMat)); break; } } }
protected void InitTextureLighting() { if ( targetRenderSystem.Capabilities.TextureUnitCount < 2 ) LogManager.Instance.Write( "--WARNING--At least 2 available texture units are required for BSP dynamic lighting!" ); Texture texLight = TextureLight.CreateTexture(); textureLightMaterial = (Material)MaterialManager.Instance.GetByName( "Axiom/BspTextureLightMaterial" ); if ( textureLightMaterial == null ) { textureLightMaterial = (Material)MaterialManager.Instance.Create( "Axiom/BspTextureLightMaterial", ResourceGroupManager.DefaultResourceGroupName ); textureLightPass = textureLightMaterial.GetTechnique( 0 ).GetPass( 0 ); // the texture light TextureUnitState tex = textureLightPass.CreateTextureUnitState( texLight.Name ); tex.SetColorOperation( LayerBlendOperation.Modulate ); tex.ColorBlendMode.source2 = LayerBlendSource.Diffuse; tex.SetAlphaOperation( LayerBlendOperationEx.Modulate ); tex.AlphaBlendMode.source2 = LayerBlendSource.Diffuse; tex.TextureCoordSet = 2; tex.SetTextureAddressingMode( TextureAddressing.Clamp ); // The geometry texture without lightmap. Use the light texture on this // pass, the appropriate texture will be rendered at RenderTextureLighting tex = textureLightPass.CreateTextureUnitState( texLight.Name ); tex.SetColorOperation( LayerBlendOperation.Modulate ); tex.SetAlphaOperation( LayerBlendOperationEx.Modulate ); tex.SetTextureAddressingMode( TextureAddressing.Wrap ); textureLightPass.SetSceneBlending( SceneBlendType.TransparentAlpha ); textureLightMaterial.CullingMode = CullingMode.None; textureLightMaterial.Lighting = false; } else { textureLightPass = textureLightMaterial.GetTechnique( 0 ).GetPass( 0 ); } }
public void Initialize(Window window) { m_window = window; InitializeOculus(); InitializeGloves(); // Create the root object m_root = new Root("GlovesLog.log"); // Configure the render system SetRenderingSystem(); // Create render window m_renderWindow = m_root.Initialize(true); // Loads the resources ResourceGroupManager.Instance.AddResourceLocation("media", "Folder", true); ResourceGroupManager.Instance.InitializeAllResourceGroups(); // Create the screen manager m_sceneManager = m_root.CreateSceneManager(SceneType.Generic); InitializeCameras(); InitializeViewports(); InitializeLight(); // Create material to render ClEye camera input m_axiomMaterial = MaterialManager.Instance.Create("dynamicResource", "Materials") as Material; // Create texture to render the CLEye camera input to m_texture = TextureManager.Instance.CreateManual("DynamicTexture", ResourceGroupManager.DefaultResourceGroupName, TextureType.TwoD, 640, 480, 2, PixelFormat.R8G8B8, TextureUsage.RenderTarget); // Set the cameras in the scene SceneNode cameraNode = m_sceneManager.RootSceneNode.CreateChildSceneNode("CameraNode", new Vector3(0, 0, 0)); cameraNode.AttachObject(m_camera[0]); cameraNode.AttachObject(m_camera[1]); InitializeEntities(); // Initialize the material that will draw the camera input m_axiomMaterial.GetTechnique(0).GetPass(0).CreateTextureUnitState("DynamicTexture"); m_axiomMaterial.GetTechnique(0).GetPass(0).DepthCheck = false; m_axiomMaterial.GetTechnique(0).GetPass(0).DepthWrite = false; m_axiomMaterial.GetTechnique(0).GetPass(0).LightingEnabled = false; // Initialize the rectangle input onto which the camera input will be rendered m_rect = new Rectangle2D(true); //m_rect.SetCorners(-1.15f, 1.0f, 1.15f, -1.0f); m_rect.SetCorners(-0.85f, 0.7f, 0.85f, -0.7f); m_rect.Material = m_axiomMaterial; m_rect.RenderQueueGroup = RenderQueueGroupID.Background; SceneNode node = m_sceneManager.RootSceneNode.CreateChildSceneNode("Background"); node.AttachObject(m_rect); // Set the function to the FrameStarted event m_root.FrameStarted += FrameStarted; InitializeCLEyeCameras(); // Not recording m_record = false; // Not loading from file m_renderFromFile = false; // Initialize the gloves capture string arrays m_gloveCaptureL = new string[30]; m_gloveCaptureL[0] = "Left Glove Capture"; m_gloveCaptureL[1] = "\r\n"; m_gloveCaptureR = new string[30]; m_gloveCaptureR[0] = "Right Glove Capture"; m_gloveCaptureR[1] = "\r\n"; }
public void UpdateMaterial(Material material) { if (useParams) { // Note: If we change the number of alpha map mosaics, we may need to update the GPU // shader to support Pass pass = material.GetTechnique(0).GetPass(0); GpuProgramParameters vertexParams = pass.VertexProgramParameters; vertexParams.SetNamedConstant("textureTileSize", new Vector3(textureTileSize, 0, 0)); // set splatting textures int offset = alphaMapMosaicNames.Length; for (int i = 0; i < layerTextureNames.Length; i++) { pass.GetTextureUnitState(offset + i).SetTextureName(layerTextureNames[i]); } pass.GetTextureUnitState(10).SetTextureName(detailTextureName); } }
public DebugRenderable( Node parent ) { _parent = parent; string materialName = "Axiom/Debug/AxesMat"; _material = (Material)MaterialManager.Instance[ materialName ]; if ( _material == null ) { _material = (Material)MaterialManager.Instance.Create( materialName, ResourceGroupManager.InternalResourceGroupName ); Pass p = _material.GetTechnique( 0 ).GetPass( 0 ); p.LightingEnabled = false; //TODO: p.PolygonModeOverrideable = false; p.VertexColorTracking = TrackVertexColor.Ambient; p.SetSceneBlending( SceneBlendType.TransparentAlpha ); p.CullingMode = CullingMode.None; p.DepthWrite = false; } string meshName = "Axiom/Debug/AxesMesh"; _mesh = MeshManager.Instance[ meshName ]; if ( _mesh == null ) { ManualObject mo = new ManualObject( "tmp" ); mo.Begin( Material.Name, OperationType.TriangleList ); /* 3 axes, each made up of 2 of these (base plane = XY) * .------------|\ * '------------|/ */ mo.EstimateVertexCount( 7 * 2 * 3 ); mo.EstimateIndexCount( 3 * 2 * 3 ); Quaternion[] quat = new Quaternion[ 6 ]; ColorEx[] col = new ColorEx[ 3 ]; // x-axis quat[ 0 ] = Quaternion.Identity; quat[ 1 ] = Quaternion.FromAxes( Vector3.UnitX, Vector3.NegativeUnitZ, Vector3.UnitY ); col[ 0 ] = ColorEx.Red; col[ 0 ].a = 0.8f; // y-axis quat[ 2 ] = Quaternion.FromAxes( Vector3.UnitY, Vector3.NegativeUnitX, Vector3.UnitZ ); quat[ 3 ] = Quaternion.FromAxes( Vector3.UnitY, Vector3.UnitZ, Vector3.UnitX ); col[ 1 ] = ColorEx.Green; col[ 1 ].a = 0.8f; // z-axis quat[ 4 ] = Quaternion.FromAxes( Vector3.UnitZ, Vector3.UnitY, Vector3.NegativeUnitX ); quat[ 5 ] = Quaternion.FromAxes( Vector3.UnitZ, Vector3.UnitX, Vector3.UnitY ); col[ 2 ] = ColorEx.Blue; col[ 2 ].a = 0.8f; Vector3[] basepos = new Vector3[ 7 ] { // stalk new Vector3(0f, 0.05f, 0f), new Vector3(0f, -0.05f, 0f), new Vector3(0.7f, -0.05f, 0f), new Vector3(0.7f, 0.05f, 0f), // head new Vector3(0.7f, -0.15f, 0f), new Vector3(1f, 0f, 0f), new Vector3(0.7f, 0.15f, 0f) }; // vertices // 6 arrows for ( int i = 0; i < 6; ++i ) { // 7 points for ( int p = 0; p < 7; ++p ) { Vector3 pos = quat[ i ] * basepos[ p ]; mo.Position( pos ); mo.Color( col[ i / 2 ] ); } } // indices // 6 arrows for ( int i = 0; i < 6; ++i ) { ushort baseIndex = (ushort)( i * 7 ); mo.Triangle( (ushort)( baseIndex + 0 ), (ushort)( baseIndex + 1 ), (ushort)( baseIndex + 2 ) ); mo.Triangle( (ushort)( baseIndex + 0 ), (ushort)( baseIndex + 2 ), (ushort)( baseIndex + 3 ) ); mo.Triangle( (ushort)( baseIndex + 4 ), (ushort)( baseIndex + 5 ), (ushort)( baseIndex + 6 ) ); } mo.End(); _mesh = mo.ConvertToMesh( meshName, ResourceGroupManager.InternalResourceGroupName ); } }
protected override void load() { // clarabie - nov 18, 2008 // modified this to check for an existing material instead of always // creating a new one. Allows more flexibility, but also specifically allows us to // solve the problem of XNA not having fixed function support _material = (Material)MaterialManager.Instance.GetByName( "Fonts/" + _name ); if ( _material == null ) { // create a material for this font _material = (Material)MaterialManager.Instance.Create( "Fonts/" + _name, Group ); TextureUnitState unitState = null; bool blendByAlpha = false; if ( _fontType == FontType.TrueType ) { #if !( XBOX || XBOX360 ) // create the font bitmap on the fly createTexture(); // a texture layer was added in CreateTexture unitState = _material.GetTechnique( 0 ).GetPass( 0 ).GetTextureUnitState( 0 ); blendByAlpha = true; #endif } else { // load this texture // TODO In general, modify any methods like this that throw their own exception rather than returning null, so the caller can decide how to handle a missing resource. _texture = TextureManager.Instance.Load( Source, Group, TextureType.TwoD, 0 ); blendByAlpha = texture.HasAlpha; // pre-created font images unitState = Material.GetTechnique( 0 ).GetPass( 0 ).CreateTextureUnitState( Source ); } // set texture addressing mode to Clamp to eliminate fuzzy edges if ( unitState != null ) unitState.SetTextureAddressingMode( TextureAddressing.Clamp ); // set up blending mode if ( blendByAlpha ) { _material.SetSceneBlending( SceneBlendType.TransparentAlpha ); } else { // assume black background here _material.SetSceneBlending( SceneBlendType.Add ); } } }
public RSQuadOperation( CompositorInstance instance, uint pass_id, Material mat ) { Material = mat; Instance = instance; PassId = pass_id; QuadLeft = -1; QuadRight = 1; QuadTop = 1; QuadBottom = -1; mat.Load(); instance.OnMaterialSetup( new CompositorInstanceMaterialEventArgs( PassId, Material ) ); Technique = mat.GetTechnique( 0 ); Debug.Assert( Technique != null, "Material has no supported technique." ); }
/// <summary> /// Loads either an image based font, or creates one on the fly from a TrueType font file. /// </summary> protected override void LoadImpl() { // create a material for this font material = (Material)MaterialManager.Instance.Create("Fonts/" + name); TextureUnitState unitState = null; bool blendByAlpha = false; if (fontType == FontType.TrueType) { // create the font bitmap on the fly CreateTexture(); // a texture layer was added in CreateTexture unitState = material.GetTechnique(0).GetPass(0).GetTextureUnitState(0); blendByAlpha = true; } else { // pre-created font images unitState = material.GetTechnique(0).GetPass(0).CreateTextureUnitState(source); // load this texture // TODO: In general, modify any methods like this that throw their own exception rather than returning null, so the caller can decide how to handle a missing resource. Texture texture = TextureManager.Instance.Load(source); blendByAlpha = texture.HasAlpha; } // set texture addressing mode to Clamp to eliminate fuzzy edges unitState.TextureAddressing = TextureAddressing.Clamp; // set up blending mode if(blendByAlpha) { material.SetSceneBlending(SceneBlendType.TransparentAlpha); } else { // assume black background here material.SetSceneBlending(SceneBlendType.Add); } }