private static string BuildSurfaceFlagsTags(SurfaceFlags flags) { var tags = new StringBuilder(); for (int j = 0; j < 32; j++) { var flag = ( SurfaceFlags )(1u << j); var hasFlag = flags.HasFlagFast(flag); if (hasFlag) { if (!sTags.TryGetValue(flag, out var tag)) { tag = $"B{j}"; } tags.Append($"@{tag}"); } else { if (flag == SurfaceFlags.Visible) { tags.Append("@H"); } } } return(tags.ToString()); }
private void Read(EndianBinaryReader reader) { Bounds = reader.ReadBoundingSphere(); RootNode = reader.ReadObjectOffset <Node>(); Field14 = reader.ReadInt32(); Field18 = reader.ReadInt32(); Flags = ( SurfaceFlags )reader.ReadInt32(); }
void ISerializableObject.Read(EndianBinaryReader reader, object context) { Bounds = reader.ReadBoundingSphere(); Field10 = reader.ReadInt32(); Field14 = reader.ReadInt32(); RootNode = reader.ReadObjectOffset <Node>(new NodeReadContext(GeometryFormat.BasicDX)); Field1C = reader.ReadInt32(); Flags = ( SurfaceFlags )reader.ReadInt32(); }
public Surface(Device gbmDev, int width, int height, SurfaceFlags flags, SurfaceFormat format = SurfaceFormat.ARGB8888) { handle = gbm_surface_create(gbmDev.handle, width, height, format, flags); if (handle == IntPtr.Zero) { throw new NotSupportedException("[GBM] Failed to create GBM surface"); } }
public Surface(Device gbmDev, uint width, uint height, SurfaceFormat format, SurfaceFlags flags) { this.Device = gbmDev; this.surfaceHandle = gbm_surface_create(gbmDev.Handle, width, height, format, flags); if (this.surfaceHandle == null) { throw new NotSupportedException("[GBM] Failed to create GBM surface"); } }
/// <summary> /// /// </summary> /// <param name="rs"></param> /// <param name="maxTextures"></param> internal MaterialInstance ( RenderSystem rs, ContentManager content, MaterialData parameters, IEnumerable<TextureMapBind> textureBinds, SurfaceFlags surfaceFlags ) { if (rs==null) { throw new ArgumentNullException("rs"); } if (textureBinds.Count()<0 || textureBinds.Count()>MaxTextures) { throw new ArgumentException("textureCount", "Must be less or equal to " + MaxTextures.ToString() ); } // // Pipeline states : // var factory = rs.SceneRenderer.Factory; var gbufferRigid = SurfaceFlags.GBUFFER | SurfaceFlags.RIGID | surfaceFlags ; var gbufferSkinned = SurfaceFlags.GBUFFER | SurfaceFlags.SKINNED | surfaceFlags ; var shadowRigid = SurfaceFlags.SHADOW | SurfaceFlags.RIGID | surfaceFlags ; var shadowSkinned = SurfaceFlags.SHADOW | SurfaceFlags.SKINNED | surfaceFlags ; GBufferRigid = factory[ (int)gbufferRigid ]; GBufferSkinned = factory[ (int)gbufferSkinned ]; ShadowRigid = factory[ (int)shadowRigid ]; ShadowSkinned = factory[ (int)shadowSkinned ]; // // Textures : // var textures = textureBinds .Select( texBind => texBind.TextureMap.LoadTexture( content, texBind.FallbackPath ) ); var uvMods = new Vector4[MaxTextures]; textureBinds .Select( tb => tb.TextureMap ) .Select( tm => new Vector4( tm.ScaleU, tm.ScaleV, tm.OffsetU, tm.OffsetV ) ) .ToArray() .CopyTo( uvMods, 0 ); shaderResources = textures.Select( tex => tex.Srv ).ToArray(); // // Constants : // constBufferParams = new ConstantBuffer( rs.Device, typeof(MaterialData) ); constBufferParams.SetData( parameters ); constBufferUVMods = new ConstantBuffer( rs.Device, typeof(Vector4), MaxTextures ); constBufferUVMods.SetData( uvMods ); }
/// <summary> /// /// </summary> /// <param name="material"></param> /// <param name="flags"></param> /// <returns></returns> SurfaceFlags ApplyFlags(MeshInstance instance, SurfaceFlags flags) { if (instance.IsSkinned) { flags |= SurfaceFlags.SKINNED; } else { flags |= SurfaceFlags.RIGID; } return(flags); }
public short AllocateSurfaceFlags(int flags) { var index = Convert.ToInt16(coct.SurfaceFlagsList.Count); var ent7 = new SurfaceFlags { Flags = flags, }; coct.SurfaceFlagsList.Add(ent7); return(index); }
public Surface(BinaryReader reader, bool simple = false) { if (!simple) { Material = reader.ReadByte(); Flags = (SurfaceFlags) reader.ReadByte(); Brightness = reader.ReadByte(); Light = reader.ReadByte(); } else { Material = reader.ReadByte(); Flags = SurfaceFlags.None; Brightness = 0; Light = reader.ReadByte(); } }
public Surface(BinaryReader reader, bool simple = false) { if (!simple) { Material = reader.ReadByte(); Flags = (SurfaceFlags)reader.ReadByte(); Brightness = reader.ReadByte(); Light = reader.ReadByte(); } else { Material = reader.ReadByte(); Flags = SurfaceFlags.None; Brightness = 0; Light = reader.ReadByte(); } }
public short AllocateSurfaceFlags(int flags) { var index = coct.SurfaceFlagsList.FindIndex(it => it.Flags == flags); if (index < 0) { index = coct.SurfaceFlagsList.Count; var ent7 = new SurfaceFlags { Flags = flags, }; coct.SurfaceFlagsList.Add(ent7); } return(Convert.ToInt16(index)); }
/// <summary> /// /// </summary> /// <param name="ps"></param> /// <param name="flags"></param> void Enum(PipelineState ps, SurfaceFlags flags) { ps.RasterizerState = RasterizerState.CullCW; if (flags.HasFlag(SurfaceFlags.SKINNED)) { ps.VertexInputElements = VertexColorTextureTBNSkinned.Elements; } if (flags.HasFlag(SurfaceFlags.RIGID)) { ps.VertexInputElements = VertexColorTextureTBNRigid.Elements; } if (flags.HasFlag(SurfaceFlags.SHADOW)) { ps.RasterizerState = RasterizerState.CullNone; } }
static BufferObject CreateCursor(IntPtr gbm, MouseCursor cursor) { if (cursor.Width > 64 || cursor.Height > 64) { Debug.Print("[KMS] Cursor size {0}x{1} unsupported. Maximum is 64x64.", cursor.Width, cursor.Height); return(default(BufferObject)); } int width = 64; int height = 64; SurfaceFormat format = SurfaceFormat.ARGB8888; SurfaceFlags usage = SurfaceFlags.Cursor64x64 | SurfaceFlags.Write; Debug.Print("[KMS] Gbm.CreateBuffer({0:X}, {1}, {2}, {3}, {4}).", gbm, width, height, format, usage); BufferObject bo = Gbm.CreateBuffer( gbm, width, height, format, usage); if (bo == BufferObject.Zero) { Debug.Print("[KMS] Failed to create buffer."); return(bo); } // Copy cursor.Data into a new buffer of the correct size byte[] cursor_data = new byte[width * height * 4]; for (int y = 0; y < cursor.Height; y++) { int dst_offset = y * width * 4; int src_offset = y * cursor.Width * 4; int src_length = cursor.Width * 4; Array.Copy( cursor.Data, src_offset, cursor_data, dst_offset, src_length); } bo.Write(cursor_data); return(bo); }
static BrushMesh.Polygon[] CreateBoxPolygons(SurfaceLayers layers, SurfaceFlags surfaceFlags) { return(new[] { // left/right new BrushMesh.Polygon { surfaceID = 0, firstEdge = 0, edgeCount = 4, description = new SurfaceDescription { UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0 }, layers = layers }, new BrushMesh.Polygon { surfaceID = 1, firstEdge = 4, edgeCount = 4, description = new SurfaceDescription { UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0 }, layers = layers }, // front/back new BrushMesh.Polygon { surfaceID = 2, firstEdge = 8, edgeCount = 4, description = new SurfaceDescription { UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0 }, layers = layers }, new BrushMesh.Polygon { surfaceID = 3, firstEdge = 12, edgeCount = 4, description = new SurfaceDescription { UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0 }, layers = layers }, // top/down new BrushMesh.Polygon { surfaceID = 4, firstEdge = 16, edgeCount = 4, description = new SurfaceDescription { UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0 }, layers = layers }, new BrushMesh.Polygon { surfaceID = 5, firstEdge = 20, edgeCount = 4, description = new SurfaceDescription { UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0 }, layers = layers } }); }
static extern gbm_surface *gbm_surface_create(gbm_device *deviceHandle, uint width, uint height, SurfaceFormat format, SurfaceFlags flags);
/// <summary> /// /// </summary> /// <param name="material"></param> /// <param name="flags"></param> /// <returns></returns> SurfaceFlags ApplyFlags ( MaterialInstance material, MeshInstance instance, SurfaceFlags flags ) { //if (material!=null) { // switch ( material.Options ) { // case MaterialOptions.SingleLayer : flags |= SurfaceFlags.LAYER0; break; // case MaterialOptions.DoubleLayer : flags |= SurfaceFlags.LAYER0|SurfaceFlags.LAYER1; break; // case MaterialOptions.TripleLayer : flags |= SurfaceFlags.LAYER0|SurfaceFlags.LAYER1|SurfaceFlags.LAYER2; break; // case MaterialOptions.QuadLayer : flags |= SurfaceFlags.LAYER0|SurfaceFlags.LAYER1|SurfaceFlags.LAYER2|SurfaceFlags.LAYER3; break; // case MaterialOptions.Terrain : flags |= SurfaceFlags.TERRAIN; break; // case MaterialOptions.TriplanarWorldSingle : flags |= SurfaceFlags.TRIPLANAR_SINGLE; break; // case MaterialOptions.TriplanarWorldDouble : flags |= SurfaceFlags.TRIPLANAR_DOUBLE; break; // case MaterialOptions.TriplanarWorldTriple : flags |= SurfaceFlags.TRIPLANAR_TRIPLE; break; // } //} if (instance.IsSkinned) { flags |= SurfaceFlags.SKINNED; } else { flags |= SurfaceFlags.RIGID; } return flags; }
/// <summary> /// /// </summary> /// <param name="ps"></param> /// <param name="flags"></param> void Enum ( PipelineState ps, SurfaceFlags flags ) { ps.RasterizerState = RasterizerState.CullCW; if (flags.HasFlag( SurfaceFlags.SKINNED )) { ps.VertexInputElements = VertexColorTextureTBNSkinned.Elements; } if (flags.HasFlag( SurfaceFlags.RIGID )) { ps.VertexInputElements = VertexColorTextureTBNRigid.Elements; } if (flags.HasFlag( SurfaceFlags.VOXELIZE )) { ps.RasterizerState = RasterizerState.CullNone; ps.DepthStencilState = DepthStencilState.None; } }
public MaterialInfoParameter(string name, bool clearSolid, SurfaceFlags surfaceFlags, ContentFlags contentFlags) { Name = name; ClearSolid = clearSolid; SurfaceFlags = surfaceFlags; ContentFlags = contentFlags; }
/// <summary> /// Creates a cube <see cref="RealtimeCSG.Foundation.BrushMesh"/> with bounds defined by <paramref name="min"/> and <paramref name="max"/>, its <paramref name="layers"/> and optional <paramref name="surfaceFlags"/> /// </summary> /// <remarks><note>These methods are a work in progress and may change somewhat over time</note></remarks> /// <param name="min">The corner of the cube with the smallest x,y,z values</param> /// <param name="max">The corner of the cube with the largest x,y,z values</param> /// <param name="layers">The <see cref="RealtimeCSG.Foundation.SurfaceLayers"/> that define how the surfaces of this cube are rendered or if they need to be part of a collider etc.</param> /// <param name="surfaceFlags">Optional flags that modify surface behavior.</param> /// <returns>A <see cref="RealtimeCSG.Foundation.BrushMesh"/> on success, null on failure</returns> public static BrushMesh CreateCube(UnityEngine.Vector3 min, UnityEngine.Vector3 max, SurfaceLayers layers, SurfaceFlags surfaceFlags = SurfaceFlags.None) { if (min.x == max.x || min.y == max.y || min.z == max.z) { return(null); } if (min.x > max.x) { float x = min.x; min.x = max.x; max.x = x; } if (min.y > max.y) { float y = min.y; min.y = max.y; max.y = y; } if (min.z > max.z) { float z = min.z; min.z = max.z; max.z = z; } var surfaceMatrices = new[] { // left/right new UVMatrix { U = new Vector4(-1, 0, 0, -min.x), V = new Vector4(0, 1, 0, min.y) }, new UVMatrix { U = new Vector4(1, 0, 0, min.x), V = new Vector4(0, 1, 0, min.y) }, // front/back new UVMatrix { U = new Vector4(0, 0, 1, min.z), V = new Vector4(0, 1, 0, min.y) }, new UVMatrix { U = new Vector4(0, 0, -1, -min.z), V = new Vector4(0, 1, 0, min.y) }, // top/down new UVMatrix { U = new Vector4(-1, 0, 0, -min.x), V = new Vector4(0, 0, -1, -min.z) }, new UVMatrix { U = new Vector4(1, 0, 0, min.x), V = new Vector4(0, 0, -1, -min.z) }, }; return(new BrushMesh { polygons = new[] { // left/right new BrushMesh.Polygon { polygonID = 0, firstEdge = 0, edgeCount = 4, surface = new SurfaceDescription { UV0 = surfaceMatrices[0], surfaceFlags = surfaceFlags, smoothingGroup = 0 }, layers = layers }, new BrushMesh.Polygon { polygonID = 1, firstEdge = 4, edgeCount = 4, surface = new SurfaceDescription { UV0 = surfaceMatrices[1], surfaceFlags = surfaceFlags, smoothingGroup = 0 }, layers = layers }, // front/back new BrushMesh.Polygon { polygonID = 2, firstEdge = 8, edgeCount = 4, surface = new SurfaceDescription { UV0 = surfaceMatrices[2], surfaceFlags = surfaceFlags, smoothingGroup = 0 }, layers = layers }, new BrushMesh.Polygon { polygonID = 3, firstEdge = 12, edgeCount = 4, surface = new SurfaceDescription { UV0 = surfaceMatrices[3], surfaceFlags = surfaceFlags, smoothingGroup = 0 }, layers = layers }, // top/down new BrushMesh.Polygon { polygonID = 4, firstEdge = 16, edgeCount = 4, surface = new SurfaceDescription { UV0 = surfaceMatrices[4], surfaceFlags = surfaceFlags, smoothingGroup = 0 }, layers = layers }, new BrushMesh.Polygon { polygonID = 5, firstEdge = 20, edgeCount = 4, surface = new SurfaceDescription { UV0 = surfaceMatrices[5], surfaceFlags = surfaceFlags, smoothingGroup = 0 }, layers = layers } }, halfEdges = new[] { // polygon 0 new BrushMesh.HalfEdge { twinIndex = 17, vertexIndex = 0 }, // 0 new BrushMesh.HalfEdge { twinIndex = 8, vertexIndex = 1 }, // 1 new BrushMesh.HalfEdge { twinIndex = 20, vertexIndex = 2 }, // 2 new BrushMesh.HalfEdge { twinIndex = 13, vertexIndex = 3 }, // 3 // polygon 1 new BrushMesh.HalfEdge { twinIndex = 10, vertexIndex = 4 }, // 4 new BrushMesh.HalfEdge { twinIndex = 19, vertexIndex = 5 }, // 5 new BrushMesh.HalfEdge { twinIndex = 15, vertexIndex = 6 }, // 6 new BrushMesh.HalfEdge { twinIndex = 22, vertexIndex = 7 }, // 7 // polygon 2 new BrushMesh.HalfEdge { twinIndex = 1, vertexIndex = 0 }, // 8 new BrushMesh.HalfEdge { twinIndex = 16, vertexIndex = 4 }, // 9 new BrushMesh.HalfEdge { twinIndex = 4, vertexIndex = 7 }, // 10 new BrushMesh.HalfEdge { twinIndex = 21, vertexIndex = 1 }, // 11 // polygon 3 new BrushMesh.HalfEdge { twinIndex = 18, vertexIndex = 3 }, // 16 new BrushMesh.HalfEdge { twinIndex = 3, vertexIndex = 2 }, // 17 new BrushMesh.HalfEdge { twinIndex = 23, vertexIndex = 6 }, // 18 new BrushMesh.HalfEdge { twinIndex = 6, vertexIndex = 5 }, // 19 // polygon 4 new BrushMesh.HalfEdge { twinIndex = 9, vertexIndex = 0 }, // 20 new BrushMesh.HalfEdge { twinIndex = 0, vertexIndex = 3 }, // 21 new BrushMesh.HalfEdge { twinIndex = 12, vertexIndex = 5 }, // 22 new BrushMesh.HalfEdge { twinIndex = 5, vertexIndex = 4 }, // 23 // polygon 5 new BrushMesh.HalfEdge { twinIndex = 2, vertexIndex = 1 }, // 12 new BrushMesh.HalfEdge { twinIndex = 11, vertexIndex = 7 }, // 13 new BrushMesh.HalfEdge { twinIndex = 7, vertexIndex = 6 }, // 14 new BrushMesh.HalfEdge { twinIndex = 14, vertexIndex = 2 } // 15 }, vertices = new[] { new Vector3(min.x, min.y, min.z), // 0 new Vector3(min.x, max.y, min.z), // 1 new Vector3(max.x, max.y, min.z), // 2 new Vector3(max.x, min.y, min.z), // 3 new Vector3(min.x, min.y, max.z), // 4 new Vector3(max.x, min.y, max.z), // 5 new Vector3(max.x, max.y, max.z), // 6 new Vector3(min.x, max.y, max.z) // 7 } }); }
public static BrushMesh CreateSphere(Vector3 diameterXYZ, float offsetY, bool generateFromCenter, int horzSegments, int vertSegments, SurfaceLayers layers = default, SurfaceFlags surfaceFlags = SurfaceFlags.None) { var lastVertSegment = vertSegments - 1; var triangleCount = horzSegments + horzSegments; // top & bottom var quadCount = horzSegments * (vertSegments - 2); int polygonCount = triangleCount + quadCount; int halfEdgeCount = (triangleCount * 3) + (quadCount * 4); Vector3[] vertices = null; CreateSphereVertices(diameterXYZ, offsetY, generateFromCenter, horzSegments, vertSegments, ref vertices); var polygons = new Polygon[polygonCount]; var halfEdges = new HalfEdge[halfEdgeCount]; var edgeIndex = 0; var polygonIndex = 0; var startVertex = 2; for (int v = 0; v < vertSegments; v++) { var startEdge = edgeIndex; for (int h = 0, p = horzSegments - 1; h < horzSegments; p = h, h++) { var n = (h + 1) % horzSegments; int polygonEdgeCount; if (v == 0) // top { // 0 // * // ^ \ // p1 /0 1\ n0 // / 2 v // *<------* // 2 t 1 polygonEdgeCount = 3; var p1 = (p * 3) + 1; var n0 = (n * 3) + 0; var t = ((vertSegments == 2) ? (startEdge + (horzSegments * 3) + (h * 3) + 1) : (startEdge + (horzSegments * 3) + (h * 4) + 1)); halfEdges[edgeIndex + 0] = new HalfEdge { twinIndex = p1, vertexIndex = 0 }; halfEdges[edgeIndex + 1] = new HalfEdge { twinIndex = n0, vertexIndex = startVertex + (horzSegments - 1) - h }; halfEdges[edgeIndex + 2] = new HalfEdge { twinIndex = t, vertexIndex = startVertex + (horzSegments - 1) - p }; } else if (v == lastVertSegment) { // 0 t 1 // *------>* // ^ 1 / // p1 \0 2/ n0 // \ v // * // 2 polygonEdgeCount = 3; var p2 = startEdge + (p * 3) + 2; var n0 = startEdge + (n * 3) + 0; var t = ((vertSegments == 2) ? (startEdge - (horzSegments * 3) + (h * 3) + 2) : (startEdge - (horzSegments * 4) + (h * 4) + 3)); halfEdges[edgeIndex + 0] = new HalfEdge { twinIndex = p2, vertexIndex = startVertex + (horzSegments - 1) - p }; halfEdges[edgeIndex + 1] = new HalfEdge { twinIndex = t, vertexIndex = startVertex + (horzSegments - 1) - h }; halfEdges[edgeIndex + 2] = new HalfEdge { twinIndex = n0, vertexIndex = 1 }; } else { // 0 t3 1 // *------>* // ^ 1 | // p1 |0 2| n0 // | 3 v // *<------* // 3 t1 2 polygonEdgeCount = 4; var p1 = startEdge + (p * 4) + 2; var n0 = startEdge + (n * 4) + 0; var t3 = ((v == 1) ? (startEdge - (horzSegments * 3) + (h * 3) + 2) : (startEdge - (horzSegments * 4) + (h * 4) + 3)); var t1 = ((v == lastVertSegment - 1) ? (startEdge + (horzSegments * 4) + (h * 3) + 1) : (startEdge + (horzSegments * 4) + (h * 4) + 1)); halfEdges[edgeIndex + 0] = new HalfEdge { twinIndex = p1, vertexIndex = startVertex + (horzSegments - 1) - p }; halfEdges[edgeIndex + 1] = new HalfEdge { twinIndex = t3, vertexIndex = startVertex + (horzSegments - 1) - h }; halfEdges[edgeIndex + 2] = new HalfEdge { twinIndex = n0, vertexIndex = startVertex + (horzSegments - 1) - h + horzSegments }; halfEdges[edgeIndex + 3] = new HalfEdge { twinIndex = t1, vertexIndex = startVertex + (horzSegments - 1) - p + horzSegments }; } polygons[polygonIndex] = new Polygon { surfaceID = polygonIndex, firstEdge = edgeIndex, edgeCount = polygonEdgeCount, description = new SurfaceDescription { UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0 }, layers = layers }; edgeIndex += polygonEdgeCount; polygonIndex++; } if (v > 0) { startVertex += horzSegments; } } return(new BrushMesh { polygons = polygons, halfEdges = halfEdges, vertices = vertices }); }
static extern IntPtr gbm_surface_create(IntPtr gbm, int width, int height, SurfaceFormat format, SurfaceFlags flags);
public static extern BufferObject CreateBuffer(Device gbm, int width, int height, SurfaceFormat format, SurfaceFlags flags);
public static CSGBrushMeshAsset CreateBoxAsset(UnityEngine.Vector3 min, UnityEngine.Vector3 max, CSGSurfaceAsset surfaceAsset, SurfaceFlags surfaceFlags = SurfaceFlags.None) { return(CreateBoxAsset(min, max, new CSGSurfaceAsset[] { surfaceAsset, surfaceAsset, surfaceAsset, surfaceAsset, surfaceAsset, surfaceAsset }, surfaceFlags)); }
public static BrushMesh CreateBox(UnityEngine.Vector3 min, UnityEngine.Vector3 max, SurfaceLayers layers, SurfaceFlags surfaceFlags = SurfaceFlags.None) { if (!BoundsExtensions.IsValid(min, max)) { return(null); } if (min.x > max.x) { float x = min.x; min.x = max.x; max.x = x; } if (min.y > max.y) { float y = min.y; min.y = max.y; max.y = y; } if (min.z > max.z) { float z = min.z; min.z = max.z; max.z = z; } return(new BrushMesh { polygons = CreateBoxPolygons(layers, surfaceFlags), halfEdges = boxHalfEdges.ToArray(), vertices = CreateBoxVertices(min, max) }); }
/// <summary> /// Parses the material, if there are any errors during parsing the defaultShader will be set. /// </summary> /// <param name="lexer"></param> private void ParseMaterial(idLexer lexer) { _registerCount = PredefinedRegisterCount; // leave space for the parms to be copied in. for(int i = 0; i < _registerCount; i++) { _parsingData.RegisterIsTemporary[i] = true; // they aren't constants that can be folded. } TextureRepeat textureRepeatDefault = TextureRepeat.Repeat; // allow a global setting for repeat. idToken token = null; string tokenValue; string tokenLower; int count; while(true) { if(TestMaterialFlag(Renderer.MaterialFlags.Defaulted) == true) { // we have a parse error. return; } if((token = lexer.ExpectAnyToken()) == null) { this.MaterialFlag = MaterialFlags.Defaulted; return; } tokenValue = token.ToString(); tokenLower = tokenValue.ToLower(); // end of material definition if(tokenLower == "}") { break; } else if(tokenLower == "qer_editorimage") { token = lexer.ReadTokenOnLine(); _editorImageName = (token != null) ? token.ToString() : string.Empty; lexer.SkipRestOfLine(); } else if(tokenLower == "description") { token = lexer.ReadTokenOnLine(); _description = (token != null) ? token.ToString() : string.Empty; } // check for the surface / content bit flags. else if(CheckSurfaceParameter(token) == true) { } else if(tokenLower == "polygonoffset") { this.MaterialFlag = Renderer.MaterialFlags.PolygonOffset; if((token = lexer.ReadTokenOnLine()) == null) { _polygonOffset = 1; } else { _polygonOffset = token.ToFloat(); } } // noshadow. else if(tokenLower == "noshadows") { this.MaterialFlag = MaterialFlags.NoShadows; } else if(tokenLower == "suppressinsubview") { _suppressInSubview = true; } else if(tokenLower == "portalsky") { _portalSky = true; } else if(tokenLower == "noselfshadow") { this.MaterialFlag = Renderer.MaterialFlags.NoSelfShadow; } else if(tokenLower == "noportalfog") { this.MaterialFlag = Renderer.MaterialFlags.NoPortalFog; } // forceShadows allows nodraw surfaces to cast shadows. else if(tokenLower == "forceshadows") { this.MaterialFlag = Renderer.MaterialFlags.ForceShadows; } // overlay / decal suppression. else if(tokenLower == "nooverlays") { _allowOverlays = false; } // moster blood overlay forcing for alpha tested or translucent surfaces. else if(tokenLower == "forceoverlays") { _parsingData.ForceOverlays = true; } else if(tokenLower == "translucent") { _coverage = MaterialCoverage.Translucent; } // global zero clamp. else if(tokenLower == "zeroclamp") { textureRepeatDefault = TextureRepeat.ClampToZero; } // global clamp. else if(tokenLower == "clamp") { textureRepeatDefault = TextureRepeat.Clamp; } // global clamp. else if(tokenLower == "alphazeroclamp") { textureRepeatDefault = TextureRepeat.ClampToZero; } // forceOpaque is used for skies-behind-windows. else if(tokenLower == "forceopaque") { _coverage = MaterialCoverage.Opaque; } else if(tokenLower == "twosided") { _cullType = CullType.TwoSided; // twoSided implies no-shadows, because the shadow // volume would be coplanar with the surface, giving depth fighting // we could make this no-self-shadows, but it may be more important // to receive shadows from no-self-shadow monsters. this.MaterialFlag = Renderer.MaterialFlags.NoShadows; } else if(tokenLower == "backsided") { _cullType = CullType.Back; // the shadow code doesn't handle this, so just disable shadows. // We could fix this in the future if there was a need. this.MaterialFlag = Renderer.MaterialFlags.NoShadows; } else if(tokenLower == "foglight") { _fogLight = true; } else if(tokenLower == "blendlight") { _blendLight = true; } else if(tokenLower == "ambientlight") { _ambientLight = true; } else if(tokenLower == "mirror") { _sort = (float) MaterialSort.Subview; _coverage = MaterialCoverage.Opaque; } else if(tokenLower == "nofog") { _noFog = true; } else if(tokenLower == "unsmoothedtangents") { _unsmoothedTangents = true; } // lightFallofImage <imageprogram> // specifies the image to use for the third axis of projected // light volumes. else if(tokenLower == "lightfalloffimage") { _lightFalloffImage = idE.ImageManager.ImageFromFile(ParsePastImageProgram(lexer), TextureFilter.Default, false, TextureRepeat.Clamp, TextureDepth.Default); } // guisurf <guifile> | guisurf entity // an entity guisurf must have an idUserInterface // specified in the renderEntity. else if(tokenLower == "guisurf") { token = lexer.ReadTokenOnLine(); tokenLower = token.ToString().ToLower(); if(tokenLower == "entity") { _entityGui = 1; } else if(tokenLower == "entity2") { _entityGui = 2; } else if(tokenLower == "entity3") { _entityGui = 3; } else { _userInterface = idE.UIManager.FindInterface(token.ToString(), true); } } // sort. else if(tokenLower == "sort") { ParseSort(lexer); } // spectrum <integer>. else if(tokenLower == "spectrum") { int.TryParse(lexer.ReadTokenOnLine().ToString(), out _spectrum); } // deform < sprite | tube | flare >. else if(tokenLower == "deform") { ParseDeform(lexer); } // decalInfo <staySeconds> <fadeSeconds> (<start rgb>) (<end rgb>). else if(tokenLower == "decalinfo") { ParseDecalInfo(lexer); } // renderbump <args...>. else if(tokenLower == "renderbump") { _renderBump = lexer.ParseRestOfLine(); } // diffusemap for stage shortcut. else if(tokenLower == "diffusemap") { idLexer newLexer = new idLexer(LexerOptions.NoFatalErrors | LexerOptions.NoStringConcatination | LexerOptions.NoStringEscapeCharacters | LexerOptions.AllowPathNames); newLexer.LoadMemory(string.Format("blend diffusemap\nmap {0}\n}}\n", ParsePastImageProgram(lexer)), "diffusemap"); ParseStage(newLexer, textureRepeatDefault); } // specularmap for stage shortcut. else if(tokenLower == "specularmap") { idLexer newLexer = new idLexer(LexerOptions.NoFatalErrors | LexerOptions.NoStringConcatination | LexerOptions.NoStringEscapeCharacters | LexerOptions.AllowPathNames); newLexer.LoadMemory(string.Format("blend specularmap\nmap {0}\n}}\n", ParsePastImageProgram(lexer)), "specularmap"); ParseStage(newLexer, textureRepeatDefault); } // normalmap for stage shortcut. else if(tokenLower == "bumpmap") { idLexer newLexer = new idLexer(LexerOptions.NoFatalErrors | LexerOptions.NoStringConcatination | LexerOptions.NoStringEscapeCharacters | LexerOptions.AllowPathNames); newLexer.LoadMemory(string.Format("blend bumpmap\nmap {0}\n}}\n", ParsePastImageProgram(lexer)), "bumpmap"); ParseStage(newLexer, textureRepeatDefault); } // DECAL_MACRO for backwards compatibility with the preprocessor macros. else if(tokenLower == "decal_macro") { // polygonOffset this.MaterialFlag = Renderer.MaterialFlags.PolygonOffset; _polygonOffset = -1; // discrete _surfaceFlags |= SurfaceFlags.Discrete; _contentFlags &= ~ContentFlags.Solid; // sort decal. _sort = (float) MaterialSort.Decal; // noShadows this.MaterialFlag = Renderer.MaterialFlags.NoShadows; } else if(tokenValue == "{") { // create the new stage. ParseStage(lexer, textureRepeatDefault); } else { idConsole.WriteLine("unknown general material parameter '{0}' in '{1}'", tokenValue, this.Name); return; } } // add _flat or _white stages if needed. AddImplicitStages(); // order the diffuse / bump / specular stages properly. SortInteractionStages(); // if we need to do anything with normals (lighting or environment mapping) // and two sided lighting was asked for, flag // shouldCreateBackSides() and change culling back to single sided, // so we get proper tangent vectors on both sides. // we can't just call ReceivesLighting(), because the stages are still // in temporary form. if(_cullType == CullType.TwoSided) { count = _parsingData.Stages.Count; for(int i = 0; i < count; i++) { if((_parsingData.Stages[i].Lighting != StageLighting.Ambient) || (_parsingData.Stages[i].Texture.TextureCoordinates != TextureCoordinateGeneration.Explicit)) { if(_cullType == CullType.TwoSided) { _cullType = CullType.Front; _shouldCreateBackSides = true; } break; } } } // currently a surface can only have one unique texgen for all the stages on old hardware. TextureCoordinateGeneration firstGen = TextureCoordinateGeneration.Explicit; count = _parsingData.Stages.Count; for(int i = 0; i < count; i++) { if(_parsingData.Stages[i].Texture.TextureCoordinates != TextureCoordinateGeneration.Explicit) { if(firstGen == TextureCoordinateGeneration.Explicit) { firstGen = _parsingData.Stages[i].Texture.TextureCoordinates; } else if(firstGen != _parsingData.Stages[i].Texture.TextureCoordinates) { idConsole.Warning("material '{0}' has multiple stages with a texgen", this.Name); break; } } } }
private void Clear() { _description = "<none>"; _renderBump = string.Empty; _contentFlags = ContentFlags.Solid; _surfaceFlags = SurfaceFlags.None; _materialFlags = 0; _sort = (float) MaterialSort.Bad; _coverage = MaterialCoverage.Bad; _cullType = CullType.Front; _deformType = DeformType.None; _deformRegisters = new int[4]; _ops = null; _expressionRegisters = null; _constantRegisters = null; _stages = new MaterialStage[] { }; _stageCount = 0; _ambientStageCount = 0; _registerCount = 0; _lightFalloffImage = null; _entityGui = 0; _shouldCreateBackSides = false; _editorImageName = null; _fogLight = false; _blendLight = false; _ambientLight = false; _noFog = false; _hasSubview = false; _allowOverlays = true; _unsmoothedTangents = false; _userInterface = null; _referenceCount = 0; /*editorAlpha = 1.0;*/ _spectrum = 0; _polygonOffset = 0; _suppressInSubview = false; _portalSky = false; _decalInfo.StayTime = 10000; _decalInfo.FadeTime = 4000; _decalInfo.Start = new float[] { 1, 1, 1, 1 }; _decalInfo.End = new float[] { 0, 0, 0, 0 }; }
static CSGBrushSubMesh.Polygon[] CreateBoxAssetPolygons(CSGSurfaceAsset[] surfaces, SurfaceFlags surfaceFlags) { return(new[] { // left/right new CSGBrushSubMesh.Polygon { surfaceID = 0, firstEdge = 0, edgeCount = 4, description = new SurfaceDescription { UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0 }, surfaceAsset = surfaces[0] }, new CSGBrushSubMesh.Polygon { surfaceID = 1, firstEdge = 4, edgeCount = 4, description = new SurfaceDescription { UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0 }, surfaceAsset = surfaces[1] }, // front/back new CSGBrushSubMesh.Polygon { surfaceID = 2, firstEdge = 8, edgeCount = 4, description = new SurfaceDescription { UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0 }, surfaceAsset = surfaces[2] }, new CSGBrushSubMesh.Polygon { surfaceID = 3, firstEdge = 12, edgeCount = 4, description = new SurfaceDescription { UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0 }, surfaceAsset = surfaces[3] }, // top/down new CSGBrushSubMesh.Polygon { surfaceID = 4, firstEdge = 16, edgeCount = 4, description = new SurfaceDescription { UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0 }, surfaceAsset = surfaces[4] }, new CSGBrushSubMesh.Polygon { surfaceID = 5, firstEdge = 20, edgeCount = 4, description = new SurfaceDescription { UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0 }, surfaceAsset = surfaces[5] } }); }
public static extern Surface CreateSurface(Device gbm, int width, int height, SurfaceFormat format, SurfaceFlags flags);
public static bool HasFlagFast(this SurfaceFlags value, SurfaceFlags flag) { return((value & flag) != 0); }
public LinuxNativeWindow(IntPtr display, IntPtr gbm, int fd, int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice display_device) { Debug.Print("[KMS] Creating window on display {0:x}", display); Title = title; display_device = display_device ?? DisplayDevice.Default; if (display_device == null) { throw new NotSupportedException("[KMS] Driver does not currently support headless systems"); } window = new LinuxWindowInfo(display, fd, gbm, display_device.Id as LinuxDisplay); // Note: we only support fullscreen windows on KMS. // We implicitly override the requested width and height // by the width and height of the DisplayDevice, if any. width = display_device.Width; height = display_device.Height; bounds = new Rectangle(0, 0, width, height); client_size = bounds.Size; if (!mode.Index.HasValue) { mode = new EglGraphicsMode().SelectGraphicsMode(window, mode, 0); } Debug.Print("[KMS] Selected EGL mode {0}", mode); SurfaceFormat format = GetSurfaceFormat(display, mode); SurfaceFlags usage = SurfaceFlags.Rendering | SurfaceFlags.Scanout; if (!Gbm.IsFormatSupported(gbm, format, usage)) { Debug.Print("[KMS] Failed to find suitable surface format, using XRGB8888"); format = SurfaceFormat.XRGB8888; } Debug.Print("[KMS] Creating GBM surface on {0:x} with {1}x{2} {3} [{4}]", gbm, width, height, format, usage); IntPtr gbm_surface = Gbm.CreateSurface(gbm, width, height, format, usage); if (gbm_surface == IntPtr.Zero) { throw new NotSupportedException("[KMS] Failed to create GBM surface for rendering"); } window.Handle = gbm_surface; Debug.Print("[KMS] Created GBM surface {0:x}", window.Handle); window.CreateWindowSurface(mode.Index.Value); Debug.Print("[KMS] Created EGL surface {0:x}", window.Surface); cursor_default = CreateCursor(gbm, Cursors.Default); cursor_empty = CreateCursor(gbm, Cursors.Empty); Cursor = MouseCursor.Default; exists = true; }
static extern bool IsFormatSupported(IntPtr gbm, SurfaceFormat format, SurfaceFlags usage);
public bool IsSupportedFormat(SurfaceFormat format, SurfaceFlags flags) => gbm_device_is_format_supported(this.handle, format, flags);
/// <summary> /// Creates a cube <see cref="RealtimeCSG.Foundation.BrushMesh"/> with <paramref name="size"/> and <paramref name="layers"/> and optional <paramref name="surfaceFlags"/> /// </summary> /// <remarks><note>These methods are a work in progress and may change somewhat over time</note></remarks> /// <param name="size">The size of the cube</param> /// <param name="layers">The <see cref="RealtimeCSG.Foundation.SurfaceLayers"/> that define how the surfaces of this cube are rendered or if they need to be part of a collider etc.</param> /// <param name="surfaceFlags">Optional flags that modify surface behavior.</param> /// <returns>A <see cref="RealtimeCSG.Foundation.BrushMesh"/> on success, null on failure</returns> public static BrushMesh CreateCube(UnityEngine.Vector3 size, SurfaceLayers layers, SurfaceFlags surfaceFlags = SurfaceFlags.None) { var halfSize = size * 0.5f; return(CreateCube(-halfSize, halfSize, layers, surfaceFlags)); }
public BufferObject(Device dev, uint _width, uint _height, SurfaceFormat format, SurfaceFlags flags) { handle = gbm_bo_create(dev.Handle, _width, _height, format, flags); if (handle == null) { throw new NotSupportedException("[GBM] BO creation failed."); } }
public static extern bool IsFormatSupported(Device gbm, SurfaceFormat format, SurfaceFlags usage);
/// <summary> /// See if the current token matches one of the surface parameter bit flags. /// </summary> /// <param name="token"></param> /// <returns></returns> private bool CheckSurfaceParameter(idToken token) { string tokenLower = token.ToString().ToLower(); foreach(MaterialInfoParameter infoParameter in InfoParameters) { if(tokenLower == infoParameter.Name) { if((infoParameter.SurfaceFlags & Renderer.SurfaceFlags.TypeMask) == Renderer.SurfaceFlags.TypeMask) { // ensure we only have one surface type set _surfaceFlags &= ~SurfaceFlags.TypeMask; } _surfaceFlags |= infoParameter.SurfaceFlags; _contentFlags |= infoParameter.ContentFlags; if(infoParameter.ClearSolid == true) { _contentFlags &= ~ContentFlags.Solid; } return true; } } return false; }
public static CSGBrushMeshAsset CreateBoxAsset(UnityEngine.Vector3 size, CSGSurfaceAsset surfaceAsset, SurfaceFlags surfaceFlags = SurfaceFlags.None) { var halfSize = size * 0.5f; return(CreateBoxAsset(-halfSize, halfSize, surfaceAsset, surfaceFlags)); }
static extern bool gbm_device_is_format_supported(gbm_device *handle, SurfaceFormat format, SurfaceFlags flags);