public void EnableRendering(Vector3 origin) { Vector3[] lineColors; int[] lineIndicies; bboxShader = ShaderCompiler.BuildDefaultShader(); bboxShader.Link(); lineColors = null; lineIndicies = null; lines(LineColor, 12, out lineColors, out lineIndicies); _geo = new Box.BoxGeometry(); _pack = new PackedGeometry(); _pack.Coloring = true; _pack._indices = _geo.Indices; _pack._coords = _geo.Vertices; _pack.color = X3DTypeConverters.Vec3ToFloatArray(lineColors); _pack._colorIndicies = lineIndicies; _pack.restartIndex = -1; _pack.Interleave(); _handle = _pack.CreateHandle(); renderingEnabled = _handle.HasGeometry; InitBoundaryPoints(origin); }
public void TestContentDataURIs() { string dataUri; string[] uris; object resource; bool success; dataUri = "'data:text/plain\n#version 420 core \nlayout(location = 0) in vec3 position; '"; uris = X3DTypeConverters.GetMFString(dataUri); Assert.IsTrue(uris.Length == 1); success = SceneManager.FetchSingle(uris[0], out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); StreamReader reader = new StreamReader(resource as Stream); string dataTextPlain = reader.ReadToEnd(); string someTestShaderCodeSample = "#version 420 core \nlayout(location = 0) in vec3 position; "; Assert.AreEqual(dataTextPlain, someTestShaderCodeSample); //TODO: complete tests for data:uri as seen in https://developer.mozilla.org/en-US/docs/Web/HTTP/data_URIs }
public void TestAbsoluteWebURIs() { string url; string[] uris; object resource; bool success; url = "\"http://www.web3d.org/x3d/content/examples/Basic/DistributedInteractiveSimulation/images/left.png\" \"http://www.web3d.org/x3d/content/examples/Basic/DistributedInteractiveSimulation/images/right.png\" \"http://www.web3d.org/x3d/content/examples/Basic/DistributedInteractiveSimulation/images/front.png\""; uris = X3DTypeConverters.GetMFString(url); Assert.IsTrue(uris.Length == 3); success = SceneManager.FetchSingle(uris[0], out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); success = SceneManager.FetchSingle(uris[1], out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); success = SceneManager.FetchSingle(uris[2], out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); }
public override void Load() { base.Load(); string navType = this.type.ToUpper(); if (navType.Contains("ANY")) { NavigationType = NavigationType.Examine; } else if (navType.Contains("EXAMINE")) { NavigationType = NavigationType.Examine; } else if (navType.Contains("WALK")) { NavigationType = NavigationType.Walk; } else if (navType.Contains("FLY")) { NavigationType = NavigationType.Fly; } AvatarSize = X3DTypeConverters.SFVec3f(avatarSize); HeadlightEnabled = this.headlight; }
public static PointSet CreateFromVertexSet(List <Vertex> verticies) { PointSet ps; Coordinate coord; Color colors; Vector3[] points; ps = new PointSet(); coord = new Coordinate(); colors = new Color(); points = verticies.Select(v => v.Position).ToArray(); colors.color = X3DTypeConverters.ToString(verticies.Select(v => v.Color.Xyz).ToArray()); coord.point = X3DTypeConverters.ToString(points); coord.Parent = ps; colors.Parent = ps; ps.Children.Add(colors); ps.Children.Add(coord); ps.PrimativeType = PrimitiveType.Points; return(ps); }
public void TestMixedURIs() { string url; string[] uris; url = "\"c.jpg\" 'a.jpg' 'b.jpg' \"d.jpg\" 'e.jpg' \"f.jpg\" 'test-helloworld' " + "\"subfolder0\\file0.png\\\" " + "\"Figure14.2ElevationGridMountain.x3d\" " + "'http://www.web3d.org/x3d/content/examples/Vrml2.0Sourcebook/Chapter14-ElevationGrid/Figure14.2ElevationGridMountain.x3d' " + "\"http://www.web3d.org/x3d/content/examples/Vrml2.0Sourcebook/Chapter14-ElevationGrid/Figure14.2ElevationGridMountain.x3d\" " + "'subfolder1\\subfolder1-subfolder\\file1.ext'"; uris = X3DTypeConverters.GetMFString(url); Assert.IsTrue(uris.Length == 12); Assert.AreEqual(uris[0], "c.jpg"); Assert.AreEqual(uris[1], "a.jpg"); Assert.AreEqual(uris[2], "b.jpg"); Assert.AreEqual(uris[3], "d.jpg"); Assert.AreEqual(uris[4], "e.jpg"); Assert.AreEqual(uris[5], "f.jpg"); Assert.AreEqual(uris[6], "test-helloworld"); Assert.AreEqual(uris[7], "subfolder0\\file0.png\\"); Assert.AreEqual(uris[8], "Figure14.2ElevationGridMountain.x3d"); Assert.AreEqual(uris[9], "http://www.web3d.org/x3d/content/examples/Vrml2.0Sourcebook/Chapter14-ElevationGrid/Figure14.2ElevationGridMountain.x3d"); Assert.AreEqual(uris[10], "http://www.web3d.org/x3d/content/examples/Vrml2.0Sourcebook/Chapter14-ElevationGrid/Figure14.2ElevationGridMountain.x3d"); Assert.AreEqual(uris[11], "subfolder1\\subfolder1-subfolder\\file1.ext"); }
public static PackedGeometry Pack(IndexedLineSet ils) { PackedGeometry packed; Coordinate coordinate; packed = new PackedGeometry(); //packed.Texturing = ifs.texCoordinate != null;// || parentShape.texturingEnabled; coordinate = (Coordinate)ils.ChildrenWithAppliedReferences.FirstOrDefault(n => n.GetType() == typeof(Coordinate)); packed.RGBA = false; packed.RGB = false; packed.Coloring = false; packed.generateColorMap = false; if (coordinate != null && !string.IsNullOrEmpty(ils.coordIndex)) { packed._indices = X3DTypeConverters.ParseIndicies(ils.coordIndex); packed._coords = X3DTypeConverters.MFVec3f(coordinate.point); if (ils.coordIndex.Contains(RESTART_INDEX.ToString())) { packed.restartIndex = RESTART_INDEX; } packed.vertexStride = 2; packed.Interleave(); } return(packed); }
public override void Load() { base.Load(); int i; // The keyValue field and value_changed events are defined in RGB colour space. KeyValues = X3DTypeConverters.MFVec3f(this.keyValue); if (KeyValues.Length > Keys.Length) { Console.WriteLine("[Warning] ColorInterpolator : The number of colours in the keyValue field should be equal to the number of key frames in the key field"); } // OPTIMISE for (i = 0; i < Keys.Length; i++) { if (i >= KeyValues.Length) { map[Keys[i]] = Vector3.Zero; } else { map[Keys[i]] = KeyValues[i]; } } }
public void TestX3DTextMFString() { string text; string[] @strings; text = "\"Textnodeusing\" \"diffuseColorappearance\""; @strings = X3DTypeConverters.GetMFString(text); Assert.IsTrue(@strings.Length == 2); text = "\"SERIF\""; @strings = X3DTypeConverters.GetMFString(text); Assert.IsTrue(@strings.Length == 1); text = "\"Text node using\" \"diffuseColor appearance\""; @strings = X3DTypeConverters.GetMFString(text); Assert.IsTrue(@strings.Length == 2); text = "'Text node using' 'diffuseColor appearance'"; @strings = X3DTypeConverters.GetMFString(text); Assert.IsTrue(@strings.Length == 2); text = "'Text node using' 'diffuseColor \nappearance'"; @strings = X3DTypeConverters.GetMFString(text); Assert.IsTrue(@strings.Length == 2); text = "'Text node \n using' ' diffuseColor \nappearance'"; @strings = X3DTypeConverters.GetMFString(text); Assert.IsTrue(@strings.Length == 2); }
public static PackedGeometry Pack(LineSet lineSet) { PackedGeometry packed; Coordinate coordinate; packed = new PackedGeometry(); coordinate = (Coordinate)lineSet.ChildrenWithAppliedReferences.FirstOrDefault(n => n.GetType() == typeof(Coordinate)); packed.RGBA = false; packed.RGB = false; packed.Coloring = false; packed.generateColorMap = false; if (coordinate != null) { packed._coords = X3DTypeConverters.MFVec3f(coordinate.point); packed.restartIndex = null; packed.vertexStride = 2; packed.vertexCount = lineSet.vertexCount; packed.Interleave(); } return(packed); }
public static IndexedLineSet CreateFromVertexSet(List <Vertex> verticies) { IndexedLineSet ils; Coordinate coord; Vector3[] points; int[] indicies; int i; ils = new IndexedLineSet(); coord = new Coordinate(); points = verticies.Select(v => v.Position).ToArray(); i = -1; indicies = verticies.Select(v => ++ i).ToArray(); coord.point = X3DTypeConverters.ToString(points); ils.coordIndex = X3DTypeConverters.ToString(indicies); ils.Children.Add(coord); ils.PrimativeType = PrimitiveType.Lines; return(ils); }
public static PackedGeometry Pack(IndexedFaceSet ifs) { PackedGeometry packed; TextureCoordinate texCoordinate; Coordinate coordinate; Color colorNode; ColorRGBA colorRGBANode; packed = new PackedGeometry(); //packed.Texturing = ifs.texCoordinate != null;// || parentShape.texturingEnabled; texCoordinate = (TextureCoordinate)ifs.ChildrenWithAppliedReferences.FirstOrDefault(n => n.GetType() == typeof(TextureCoordinate)); coordinate = (Coordinate)ifs.ChildrenWithAppliedReferences.FirstOrDefault(n => n.GetType() == typeof(Coordinate)); colorNode = (Color)ifs.ChildrenWithAppliedReferences.FirstOrDefault(n => n.GetType() == typeof(Color)); colorRGBANode = (ColorRGBA)ifs.ChildrenWithAppliedReferences.FirstOrDefault(n => n.GetType() == typeof(ColorRGBA)); packed.RGBA = colorRGBANode != null; packed.RGB = colorNode != null; packed.Coloring = packed.RGBA || packed.RGB; packed.generateColorMap = packed.Coloring; if (packed.RGB && !packed.RGBA) { packed.color = X3DTypeConverters.Floats(colorNode.color); } else if (packed.RGBA && !packed.RGB) { packed.color = X3DTypeConverters.Floats(colorRGBANode.color); } if (texCoordinate != null && !string.IsNullOrEmpty(ifs.texCoordIndex)) { packed._texIndices = X3DTypeConverters.ParseIndicies(ifs.texCoordIndex); packed._texCoords = X3DTypeConverters.MFVec2f(texCoordinate.point); packed.Texturing = true; } if (coordinate != null && !string.IsNullOrEmpty(ifs.coordIndex)) { packed._indices = X3DTypeConverters.ParseIndicies(ifs.coordIndex); packed._coords = X3DTypeConverters.MFVec3f(coordinate.point); if (!string.IsNullOrEmpty(ifs.colorIndex)) { packed._colorIndicies = X3DTypeConverters.ParseIndicies(ifs.colorIndex); } if (ifs.coordIndex.Contains(RESTART_INDEX.ToString())) { packed.restartIndex = RESTART_INDEX; } packed.Interleave(); } return(packed); }
public void LinkShaderSource(string source) { ShaderSource = X3DTypeConverters.UnescapeXMLValue(source).Trim(); if (parentShader != null && parentShape != null) { parentShader.ShaderParts.Add(this); } }
public ElevationGrid BuildVaryingHeightMap(int xDimension, int zDimension, float xSpacing, float zSpacing, bool colorPerVertex, ElevationColorSequencerDelegate colorSequencer, HeightComputationDelegate geometrySequencer) { ElevationGrid g = new ElevationGrid(); Color colorNode = new Color(); int numHeights = xDimension * zDimension; int faceIndex = 0; Vector3 color; int coordIndex = 0; g.colorPerVertex = colorPerVertex; g.xDimension = xDimension.ToString(); g.zDimension = zDimension.ToString(); g.xSpacing = xSpacing; g.zSpacing = zSpacing; g.height = string.Empty; colorNode.color = string.Empty; Console.WriteLine("Building varying height map (this could take a while)"); for (int x = 0; x < xDimension; x++) { for (int z = 0; z < zDimension; z++) { if (coordIndex % 4 == 0 && coordIndex > 0) { faceIndex++; } g.height += string.Format(" {0}", geometrySequencer(x, z)); if (colorSequencer != null) { color = colorSequencer(faceIndex, coordIndex, x, z); colorNode.color += X3DTypeConverters.ToString(color) + ", "; } updateProgress(coordIndex, numHeights); coordIndex++; } } colorNode.color = colorNode.color.TrimStart(); colorNode.color = colorNode.color.Substring(0, colorNode.color.Length - 2); g.height = g.height.TrimStart(); g.Children.Add(colorNode); return(g); }
public string ToFriendlyString() { return(string.Format( "Material <ambientIntensity=\"{0}\", diffuse=\"{1}\", emissive=\"{2}\", shininess=\"{3}\", specular=\"{4}\", transparency=\"{5}\">", ambientIntensity, X3DTypeConverters.ToString(this._diffuseColor), X3DTypeConverters.ToString(this._emissiveColor), this._shininess, X3DTypeConverters.ToString(this._specularColor), this._transparency )); }
/// <summary> /// Updates the field with a new value just in the SceneGraph. /// (Changes in the field are picked up by a currrently running X3DProgrammableShaderObject) /// </summary> public void setFieldValue(string name, object value) { field field = (field)this.Children .FirstOrDefault(n => n.GetType() == typeof(field) && n.getAttribute("name").ToString() == name); Type type; object convValue; Type conv; try { type = X3DTypeConverters.X3DSimpleTypeToManagedType(field.type); convValue = Convert.ChangeType(value, type); conv = convValue.GetType(); if (conv == typeof(int)) { UpdateField(name, X3DTypeConverters.ToString((int)convValue)); } if (conv == typeof(float)) { UpdateField(name, X3DTypeConverters.ToString((float)convValue)); } if (conv == typeof(Vector3)) { UpdateField(name, X3DTypeConverters.ToString((Vector3)convValue)); } if (conv == typeof(Vector4)) { UpdateField(name, X3DTypeConverters.ToString((Vector4)convValue)); } if (conv == typeof(Matrix3)) { UpdateField(name, X3DTypeConverters.ToString((Matrix3)convValue)); } if (conv == typeof(Matrix4)) { UpdateField(name, X3DTypeConverters.ToString((Matrix4)convValue)); } } catch { Console.WriteLine("error"); } }
public void InitBoundaryPoints(Vector3 origin) { int[] colIndicies; Vector3[] verticies; Vector3[] pointColors; int[] indicies; boundaries(origin, new Vector3(1, 0, 0), out pointColors, out colIndicies, out indicies, out verticies); var _pb = new PackedGeometry(); _pb.Coloring = true; _pb._indices = indicies; _pb._coords = verticies; _pb.color = X3DTypeConverters.Vec3ToFloatArray(pointColors); _pb._colorIndicies = colIndicies; _pb.restartIndex = -1; _pb.Interleave(); _handlepb = _pb.CreateHandle(); }
public override void Load() { base.Load(); int i; _keyValues = X3DTypeConverters.Integers(this.keyValue); // OPTIMISE for (i = 0; i < Keys.Length; i++) { if (i >= _keyValues.Length) { map[Keys[i]] = 0; } else { map[Keys[i]] = _keyValues[i]; } } }
public void SetFieldValueSTR(string name, string value, string x3dType) { if (HasErrors) { return; } object v; Type type; v = X3DTypeConverters.StringToX3DSimpleTypeInstance(value, x3dType, out type); if (type == typeof(int)) { SetFieldValue(name, (int)v); } if (type == typeof(float)) { SetFieldValue(name, (float)v); } if (type == typeof(Vector3)) { SetFieldValue(name, (Vector3)v); } if (type == typeof(Vector4)) { SetFieldValue(name, (Vector4)v); } if (type == typeof(Matrix3)) { Matrix3 m = (Matrix3)v; SetFieldValue(name, ref m); } if (type == typeof(Matrix4)) { Matrix4 m = (Matrix4)v; SetFieldValue(name, ref m); } }
public static PackedGeometry Pack(PointSet pointSet) { PackedGeometry packed; Coordinate coordinate; Color colorNode; ColorRGBA colorRGBANode; packed = new PackedGeometry(); coordinate = (Coordinate)pointSet.ChildrenWithAppliedReferences.FirstOrDefault(n => n.GetType() == typeof(Coordinate)); colorNode = (Color)pointSet.ChildrenWithAppliedReferences.FirstOrDefault(n => n.GetType() == typeof(Color)); colorRGBANode = (ColorRGBA)pointSet.ChildrenWithAppliedReferences.FirstOrDefault(n => n.GetType() == typeof(ColorRGBA)); packed.RGBA = colorRGBANode != null; packed.RGB = colorNode != null; packed.Coloring = packed.RGBA || packed.RGB; packed.generateColorMap = packed.Coloring; if (packed.RGB && !packed.RGBA) { packed.color = X3DTypeConverters.Floats(colorNode.color); } else if (packed.RGBA && !packed.RGB) { packed.color = X3DTypeConverters.Floats(colorRGBANode.color); } if (coordinate != null) { packed._coords = X3DTypeConverters.MFVec3f(coordinate.point); packed.restartIndex = null; packed.vertexStride = 1; packed.Interleave(); } return(packed); }
public void TestURIWithBackupURI() { string url; string[] uris; object resource; bool success; url = "\"images/left.png\" \"http://www.web3d.org/x3d/content/examples/Basic/DistributedInteractiveSimulation/images/left.png\""; uris = X3DTypeConverters.GetMFString(url); Assert.IsTrue(uris.Length == 2); success = SceneManager.FetchSingle(uris[0], out resource); Assert.IsFalse(success); Assert.IsTrue(resource == null); // even though the relative address fails with uris[0] when looking on the file system // uris[1] should succeed in returning a new copy of the resource from a remote address. success = SceneManager.FetchSingle(uris[1], out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); }
public static bool Fetch(string url_mfstring, out object resource) { if (X3DTypeConverters.IsMFString(url_mfstring)) { string[] urls = X3DTypeConverters.GetMFString(url_mfstring); foreach (string url in urls) { if (FetchSingle(url, out resource)) { return(true); } } resource = null; return(false); } else { return(FetchSingle(url_mfstring, out resource)); } //resource = null; //return false; }
public static LineSet CreateFromVertexSet(List<Vertex> verticies, int vertexStride) { LineSet ils; Coordinate coord; Vector3[] points; int[] indicies; int i; ils = new LineSet(); coord = new Coordinate(); points = verticies.Select(v => v.Position).ToArray(); i = -1; indicies = verticies.Select(v => ++i).ToArray(); coord.point = X3DTypeConverters.ToString(points); ils.vertexCount = vertexStride; ils.Children.Add(coord); ils.PrimativeType = PrimitiveType.LineLoop; return ils; }
public override void CollectGeometry( RenderingContext rc, out GeometryHandle handle, out BoundingBox bbox, out bool Coloring, out bool Texturing) { List <Vertex> geometry; handle = GeometryHandle.Zero; bbox = BoundingBox.Zero; parentShape = GetParent <Shape>(); colorNode = (Color)this.Children.FirstOrDefault(n => n.GetType() == typeof(Color)); colorRGBANode = (ColorRGBA)this.Children.FirstOrDefault(n => n.GetType() == typeof(ColorRGBA)); texCoordinateNode = (TextureCoordinate)this.Children.FirstOrDefault(n => n.GetType() == typeof(TextureCoordinate)); RGBA = colorRGBANode != null; RGB = colorNode != null; coloring = RGBA || RGB; generateColorMap = coloring; texturing = texCoordinateNode != null || parentShape.texturingEnabled; generateTexCoordMap = texturing; Coloring = coloring; Texturing = texturing; if (RGB && !RGBA) { color = X3DTypeConverters.Floats(colorNode.color); } else if (RGBA && !RGB) { color = X3DTypeConverters.Floats(colorRGBANode.color); } _isLoaded = true; //// //// //// if (construct) { float sx = this.xSpacing; float sz = this.zSpacing; IConstructionSet constructionSet; IPerlinNoiseGenerator perlinProvider; Bitmap largePerlinImage; constructionSet = SceneManager.GetCurrentConstructionSet(); perlinProvider = constructionSet.GetPerlinNoiseProvider(); ElevationGrid generated = constructionSet.ElevationBuilder.BuildHeightmapFromGenerator( rc, perlinProvider, out largePerlinImage, 40, 40, 20, 20, 20); // build a rather large height map largePerlinImage.Dispose(); Color genColorNode = (Color)generated.Children.FirstOrDefault(n => n.GetType() == typeof(Color)); this.RGB = coloring = generateColorMap = true; this.height = generated.height; this.color = X3DTypeConverters.Floats(genColorNode.color); this.colorPerVertex = generated.colorPerVertex; this.normalPerVertex = generated.normalPerVertex; this.Children = generated.Children; this.xSpacing = generated.xSpacing; this.zSpacing = generated.zSpacing; this.xDimension = generated.xDimension; this.zDimension = generated.zDimension; } if (!this._isLoaded) { parentShape = GetParent <Shape>(); texturing = parentShape.texturingEnabled; generateTexCoordMap = texturing && texCoordinateNode == null; this._isLoaded = true; } height_mapping(); bbox = BoundingBox.CalcBoundingBox(this); geometry = BuildElevationGeometryQuads(bbox); Buffering.BufferShaderGeometry(geometry, out handle.vbo4, out handle.NumVerticies4); }
//[XmlIgnore] //public string ShaderSource; #region Rendering Methods public override void Load() { base.Load(); parentShape = GetParent <Shape>(); parentShader = GetParent <ComposedShader>(); string file; string[] mf_urls; if (!string.IsNullOrEmpty(ShaderSource)) { LinkShaderSource(ShaderSource); } else if (Urls != null) { file = Urls.FirstOrDefault(); if (!string.IsNullOrEmpty(file)) { _url = _url.TrimStart(); if (_url.StartsWith(X3DTypeConverters.DATA_TEXT_PLAIN)) { ShaderSource = _url.Remove(0, X3DTypeConverters.DATA_TEXT_PLAIN.Length).TrimStart(); LinkShaderSource(ShaderSource); } else { file = file.Replace("\"", ""); file = SceneManager.CurrentLocation + "\\" + file; if (X3DTypeConverters.IsMFString(file)) { object resource; mf_urls = X3DTypeConverters.GetMFString(file); foreach (string url in mf_urls) { if (SceneManager.FetchSingle(url, out resource)) { Stream s; s = (Stream)resource; StreamReader sr = new StreamReader(s); ShaderSource = sr.ReadToEnd(); s.Close(); break; } } } else { ShaderSource = File.ReadAllText(file); LinkShaderSource(ShaderSource); } } } } }
private bool GetTextureImageFromMFString2(string mfstring) { Rectangle imgRect; int[] textureMaxSize; int glTexWidth; int glTexHeight; string[] urls; object resource; bool actually_loaded_something; if (X3DTypeConverters.IsMFString(mfstring)) { actually_loaded_something = false; urls = X3DTypeConverters.GetMFString(mfstring); foreach (string url in urls) { if (SceneManager.FetchSingle(url, out resource)) { Stream s; s = (Stream)resource; this.image = new Bitmap(s); s.Close(); actually_loaded_something = true; break; } } if (!actually_loaded_something) { this.image = Properties.Resources.ErrorTexture; } } else { this.image = new Bitmap(mfstring); } if (this.image == null) { return(false); } /* Get the maximum texture size supported by OpenGL: */ textureMaxSize = new int[] { 0 }; GL.GetInteger(GetPName.MaxTextureSize, textureMaxSize); //gl.GetInteger(OpenGL.GL_MAX_TEXTURE_SIZE,textureMaxSize); /* Find the target width and height sizes, which is just the highest * posible power of two that'll fit into the image. */ glTexWidth = textureMaxSize[0]; glTexHeight = textureMaxSize[0]; for (int size = 1; size <= textureMaxSize[0]; size *= 2) { if (image.Width < size) { glTexWidth = size / 2; break; } if (image.Width == size) { glTexWidth = size; } } for (int size = 1; size <= textureMaxSize[0]; size *= 2) { if (image.Height < size) { glTexHeight = size / 2; break; } if (image.Height == size) { glTexHeight = size; } } if (image.Width != glTexWidth || image.Height != glTexHeight) { /* Scale the image according to OpenGL requirements */ Image newImage = image.GetThumbnailImage(glTexWidth, glTexHeight, null, IntPtr.Zero); image.Dispose(); image = (Bitmap)newImage; } //if(file.ToLower().EndsWith(".bmp")) { image.RotateFlip(RotateFlipType.RotateNoneFlipY); //TODO: figure out more efficient code /* Another way to rotate texture on draw() * gl.MatrixMode(OpenGL.GL_TEXTURE); * gl.LoadIdentity(); * gl.Scale(1.0f,-1.0f,1.0f); * gl.MatrixMode(OpenGL.GL_MODELVIEW); */ //} imgRect = new Rectangle(0, 0, image.Width, image.Height); pixelData = image.LockBits(imgRect, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); pTexImage = pixelData.Scan0; Width = image.Width; Height = image.Height; _type = InternalImageType.WindowsHandle; return(true); }
public override void Load() { base.Load(); int i; int a, b; PackedGeometry _pack; cubeHandle = GeometryHandle.Zero; innerHandle = GeometryHandle.Zero; outerHandle = GeometryHandle.Zero; generateCube = !(string.IsNullOrEmpty(frontUrl) || string.IsNullOrEmpty(backUrl) || string.IsNullOrEmpty(topUrl) || string.IsNullOrEmpty(bottomUrl) || string.IsNullOrEmpty(leftUrl) || string.IsNullOrEmpty(rightUrl)); //TODO: replace cube sides that arent available with transparent sides generateSkyAndGround = !(string.IsNullOrEmpty(groundColor) || string.IsNullOrEmpty(skyColor) || string.IsNullOrEmpty(groundAngle) || string.IsNullOrEmpty(skyAngle)); // TODO: later render both skydome and skybox together // Alpha values in skybox should provide a way to see through to skydome. // Skycolor sphere should be slightly larger than groundcolor hemisphere // and finally skybox should fit and be smaller than groundcolor hemisphere. if (generateSkyAndGround) { // Sphere // interpolate colors from groundColor and skyColor over hemispheres using specified sky and ground angles this.groundColors = X3DTypeConverters.MFVec3f(groundColor); this.groundAngles = X3DTypeConverters.Floats(groundAngle); this.skyColors = X3DTypeConverters.MFVec3f(skyColor); this.skyAngles = X3DTypeConverters.Floats(skyAngle); // Assign colors with matching angles colors = new Vector3[groundColors.Length + skyColors.Length]; for (i = 0; i < skyColors.Length; i++) { colors[i] = skyColors[i]; } for (i = skyColors.Length; i < skyColors.Length + groundColors.Length; i++) { colors[i] = groundColors[i - skyColors.Length]; } angles = new float[groundAngles.Length + skyAngles.Length + 2]; angles[0] = 0; for (i = 0; i < skyAngles.Length; i++) { angles[i + 1] = skyAngles[i]; } angles[skyAngles.Length + 1] = 0; for (i = 0; i < groundAngles.Length; i++) { angles[i + skyAngles.Length + 2] = 1.5f + groundAngles[i]; } groundDivisor = (1.0f / groundColors.Length) * (float)Math.PI; // how many colors divided over 90 degrees (lower hemisphere) skyDivisor = (1.0f / groundColors.Length) * (float)Math.PI; // how many colors divided over 90 degrees (upper hemisphere) // SKYDOME // outer sphere (sky) scaleSky = Vector3.One * 6.0f; // slightly bigger than ground hemisphere _shaderOuter = ShaderCompiler.ApplyShader(BackgroundShader.vertexShaderSource, // Make use of the BackgroundShader for Skydome Linear Interpolation BackgroundShader.fragmentShaderSource); _shaderOuter.Link(); List <Vertex> geometryOuterSphere = BuildSphereGeometryQuads(60, Vector3.Zero, 1.0f); Buffering.BufferShaderGeometry(geometryOuterSphere, out outerHandle.vbo4, out outerHandle.NumVerticies4); min = Vector3.Zero; max = Vector3.Zero; BoundingBox.CalculateBoundingBox(geometryOuterSphere, out max, out min); bboxOuter = max - min; // inner hemisphere (ground) //scaleGround = Vector3.One * 5.6f; //_shaderInner = ShaderCompiler.ApplyShader(BackgroundShader.vertexShaderSource, // BackgroundShader.fragmentShaderSource); //_shaderInner.Link(); //List<Vertex> geometryInnerHemisphere = BuildHemisphereGeometryQuads(60, new Vector3(0, 0.0f,0), 1.0f, false); //Buffering.BufferShaderGeometry(geometryInnerHemisphere, out innerHandle.vbo4, out innerHandle.NumVerticies4); //min = Vector3.Zero; //max = Vector3.Zero; //BoundingBox.CalculateBoundingBox(geometryInnerHemisphere, out max, out min); //bboxInner = max - min; skydomeTexture = MakeSkydomeTexture(); } if (generateCube) { tex_cube = createCubeMapFromURIs(); // SKYBOX // innermost skybox scaleCube = Vector3.One * 3.1f; _shaderInnerCube = ShaderCompiler.ApplyShader(CubeMapBackgroundShader.vertexShaderSource, CubeMapBackgroundShader.fragmentShaderSource); _shaderInnerCube.Link(); _pack = new PackedGeometry(); _pack._indices = _cube.Indices; _pack._coords = _cube.Vertices; _pack.Texturing = true; //_pack._colorIndicies = _boxGeometry.Colors; _pack._texCoords = _cube.Texcoords; _pack.restartIndex = -1; _pack.Interleave(); // BUFFER GEOMETRY cubeHandle = _pack.CreateHandle(); } }
public void TestFileSystemURIs() { SceneManager.CurrentLocation = X3DExamplesDirectory; string url; string[] uris; object resource; bool success; // TEST MFString PARSING // uris formatted with double quotes url = "spectrum.jpg"; uris = X3DTypeConverters.GetMFString(url); Assert.IsTrue(uris.Length == 1); Assert.AreEqual(uris[0], "spectrum.jpg"); url = "\"spectrum.jpg\""; uris = X3DTypeConverters.GetMFString(url); Assert.IsTrue(uris.Length == 1); Assert.AreEqual(uris[0], "spectrum.jpg"); url = "Background\\texture\\earth.jpg"; uris = X3DTypeConverters.GetMFString(url); Assert.IsTrue(uris.Length == 1); Assert.AreEqual(uris[0], "Background\\texture\\earth.jpg"); url = "\"Background\\texture\\earth.jpg\""; uris = X3DTypeConverters.GetMFString(url); Assert.IsTrue(uris.Length == 1); Assert.AreEqual(uris[0], "Background\\texture\\earth.jpg"); // uris formatted with single quotes url = "'spectrum.jpg'"; uris = X3DTypeConverters.GetMFString(url); Assert.IsTrue(uris.Length == 1); Assert.AreEqual(uris[0], "spectrum.jpg"); url = "'Background\\texture\\earth.jpg'"; uris = X3DTypeConverters.GetMFString(url); Assert.IsTrue(uris.Length == 1); Assert.AreEqual(uris[0], "Background\\texture\\earth.jpg"); // TEST MFString URI fetching url = "spectrum.jpg"; success = SceneManager.FetchSingle(url, out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); url = "\"spectrum.jpg\""; success = SceneManager.FetchSingle(url, out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); url = "Background\\texture\\earth.jpg"; success = SceneManager.FetchSingle(url, out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); SceneManager.CurrentLocation = X3DExamplesDirectory + "Background\\"; url = "'texture\\generic\\BK.png' 'texture\\generic\\DN.png' 'texture\\generic\\FR.png' 'texture\\generic\\LF.png' 'texture\\generic\\RT.png' 'texture\\generic\\UP.png'"; uris = X3DTypeConverters.GetMFString(url); success = SceneManager.FetchSingle(uris[0], out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); success = SceneManager.FetchSingle(uris[1], out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); success = SceneManager.FetchSingle(uris[2], out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); success = SceneManager.FetchSingle(uris[3], out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); success = SceneManager.FetchSingle(uris[4], out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); success = SceneManager.FetchSingle(uris[5], out resource); Assert.IsTrue(success); Assert.IsTrue(resource is Stream); }
public ElevationGrid BuildHeightmapFromTexture( float xSpacing, float zSpacing, Bitmap texture, float maxHeight = 1.0f) { ElevationGrid g = new ElevationGrid(); Color colorNode = new Color(); int xDimension, zDimension; int numHeights; int faceIndex = 0; int coordIndex = 0; float height; System.Drawing.Color color; Vector3 vColor; Vector3 vNTSCConversionWeight; float grayscale; g.colorPerVertex = true; g.xSpacing = xSpacing; g.zSpacing = zSpacing; g.height = string.Empty; colorNode.color = string.Empty; xDimension = texture.Width; zDimension = texture.Height; numHeights = xDimension * zDimension; g.xDimension = xDimension.ToString(); g.zDimension = zDimension.ToString(); Console.WriteLine("Building height map from texture (this could take a while)"); for (int x = 0; x < xDimension; x++) { for (int z = 0; z < zDimension; z++) { if (coordIndex % 4 == 0 && coordIndex > 0) { faceIndex++; } color = texture.GetPixel(x, z); // Convert to grayscale using NTSC conversion weights vColor = new Vector3(color.R / 255f, color.G / 255f, color.B / 255f); vNTSCConversionWeight = new Vector3(0.299f, 0.587f, 0.114f); grayscale = Vector3.Dot(vColor, vNTSCConversionWeight); // Convert color to height value height = (float)(grayscale) * maxHeight; g.height += string.Format(" {0}", height); colorNode.color += X3DTypeConverters.ToString(vColor) + ", "; updateProgress(coordIndex, numHeights); coordIndex++; } } colorNode.color = colorNode.color.Trim(); colorNode.color = colorNode.color.Substring(0, colorNode.color.Length - 2); g.height = g.height.TrimStart(); g.Children.Add(colorNode); return(g); }
public override void Load() { base.Load(); Keys = X3DTypeConverters.Floats(this.key); }