private void UpdateGeometry(Shader shader) { Mesh mesh = new Mesh(); var roomSize = 8; var plane = Meshes.CreateQuad(roomSize, roomSize, 2, 2); var xform = new Transformation(); xform.TranslateGlobal(0, -roomSize / 2, 0); mesh.Add(plane.Transform(xform)); xform.RotateZGlobal(90f); mesh.Add(plane.Transform(xform)); xform.RotateZGlobal(90f); mesh.Add(plane.Transform(xform)); xform.RotateZGlobal(90f); mesh.Add(plane.Transform(xform)); xform.RotateYGlobal(90f); mesh.Add(plane.Transform(xform)); xform.RotateYGlobal(180f); mesh.Add(plane.Transform(xform)); var sphere = Meshes.CreateSphere(1); mesh.Add(sphere); var suzanne = Obj2Mesh.FromObj(Resourcen.suzanne); mesh.Add(suzanne.Transform(System.Numerics.Matrix4x4.CreateTranslation(2, 2, -2))); geometry = VAOLoader.FromMesh(mesh, shader); }
public void ShaderChanged(string name, Shader shader) { if (ShaderName == name) { this.shader = shader; if (ReferenceEquals(shader, null)) { return; } Mesh mesh = Meshes.CreateQuad(10, 10, 10, 10); var sphere = Meshes.CreateSphere(0.5f, 2); sphere.SetConstantUV(new System.Numerics.Vector2(0.5f, 0.5f)); var xform = new Transformation(); xform.TranslateLocal(0, 2, -2); mesh.Add(sphere.Transform(xform)); xform.TranslateGlobal(0, 0, 2); mesh.Add(sphere.Transform(xform)); xform.TranslateGlobal(2, 0, -1); mesh.Add(sphere.Transform(xform)); geometry = VAOLoader.FromMesh(mesh, shader); } else if (ShaderDepthName == name) { this.shaderDepth = shader; if (ReferenceEquals(shaderDepth, null)) { return; } //todo: radeon cards make errors with geometry bound to one shader and use in other shaders because of binding id changes } }
public MainVisual(IRenderState renderState, IContentLoader contentLoader) { renderState.Set(new ClearColorState(1, 1, 1, 1)); renderState.Set(new DepthTest(true)); renderState.Set(new FaceCullingModeState(FaceCullingMode.BACK_SIDE)); var envMap = contentLoader.Load <ITexture2D>("beach"); envMap.WrapFunction = TextureWrapFunction.MirroredRepeat; envMap.Filter = TextureFilterMode.Linear; var textureBinding = new TextureBinding[] { new TextureBinding(nameof(envMap), envMap) }; var sphere = Meshes.CreateSphere(1f, 4); var skySphere = sphere.Transform(Transformation.Scale(200f)).SwitchTriangleMeshWinding(); var shaderBackground = contentLoader.Load <IShaderProgram>("background.*"); visuals.Add(new MeshVisual(skySphere, shaderBackground, textureBinding)); #if SOLUTION var shaderEnvMap = contentLoader.Load <IShaderProgram>("envMapping.*"); var visSphere = new MeshVisual(sphere, shaderEnvMap, textureBinding); visSphere.SetUniform("reflective", 1f); visuals.Add(visSphere); var suzanne = contentLoader.Load <DefaultMesh>("suzanne"); var visSuzanne = new MeshVisual(suzanne.Transform(Transformation.Translation(0, -1.5f, 0)), shaderEnvMap, textureBinding); visSuzanne.SetUniform("reflective", 0.4f); visuals.Add(visSuzanne); #endif }
/// <summary>Promotes the specified object into a physical connector object.</summary> /// <remarks> /// The physics will immediately start on the object. If it doesn't have a rigidbody, the one will /// be created. /// </remarks> /// <param name="ownerModule">The part's module which will control the connector.</param> /// <param name="obj">The object to be promoted.</param> /// <param name = "interactionDistance"></param> public static KASInternalPhysicalConnector Promote( PartModule ownerModule, GameObject obj, float interactionDistance = 0) { var connectorRb = obj.GetComponent <Rigidbody>() ?? obj.AddComponent <Rigidbody>(); connectorRb.useGravity = false; connectorRb.isKinematic = ownerModule.part.packed; connectorRb.velocity = ownerModule.part.rb.velocity; connectorRb.angularVelocity = ownerModule.part.rb.angularVelocity; connectorRb.ResetInertiaTensor(); connectorRb.ResetCenterOfMass(); var connectorModule = obj.AddComponent <KASInternalPhysicalConnector>(); connectorModule.ownerModule = ownerModule; // Create the interaction collider if requested. if (interactionDistance > 0) { // This mesh is placed on a special layer which is not rendered in the game. It's only // used to detect the special zones triggers (like ladders, hatches, etc.). var interactionTriggerObj = Meshes.CreateSphere( 2 * interactionDistance, null, obj.transform, Colliders.PrimitiveCollider.Shape); interactionTriggerObj.name = InteractionAreaCollider; interactionTriggerObj.layer = (int)KspLayer.TriggerCollider; interactionTriggerObj.gameObject.GetComponent <Collider>().isTrigger = true; connectorModule.interactionTriggerObj = interactionTriggerObj; } return(connectorModule); }
public MainVisual(IRenderState renderState, IContentLoader contentLoader) { renderState.Set(new DepthTest(true)); renderState.Set(new FaceCullingModeState(FaceCullingMode.BACK_SIDE)); shaderProgramPhong = contentLoader.Load <IShaderProgram>("phong.*"); var mesh = new DefaultMesh(); var roomSize = 8; //off-center plane var plane = Meshes.CreatePlane(roomSize, roomSize, 2, 2).Transform(Transformation.Translation(0, -roomSize / 2, 0)); mesh.Add(plane); //rotate plane to create box mesh.Add(plane.Transform(Transformation.Rotation(90f, Axis.Z))); mesh.Add(plane.Transform(Transformation.Rotation(180f, Axis.Z))); mesh.Add(plane.Transform(Transformation.Rotation(270f, Axis.Z))); mesh.Add(plane.Transform(Transformation.Rotation(90f, Axis.X))); mesh.Add(plane.Transform(Transformation.Rotation(-90f, Axis.X))); var sphere = Meshes.CreateSphere(1); sphere.SetConstantUV(Vector2.Zero); //all other meshes have texture coordinates mesh.Add(sphere); var suzanne = contentLoader.Load <DefaultMesh>("suzanne"); mesh.Add(suzanne.Transform(Transformation.Translation(2, 2, -2))); geometryPhong = VAOLoader.FromMesh(mesh, shaderProgramPhong); shaderProgramToon = contentLoader.Load <IShaderProgram>("toon.*"); geometryToon = VAOLoader.FromMesh(suzanne.Transform(Transformation.Translation(2, 0, 0)), shaderProgramToon); }
public MainVisual(IRenderState renderState, IContentLoader contentLoader) { renderState.Set(BoolState <IDepthState> .Enabled); renderState.Set(BoolState <IBackfaceCullingState> .Enabled); renderState.Set(BlendStates.AlphaBlend); shaderProgram = contentLoader.Load <IShaderProgram>("phong.*"); var mesh = new DefaultMesh(); var roomSize = 8; //off-center plane var plane = Meshes.CreatePlane(roomSize, roomSize, 2, 2).Transform(new Translation3D(0, -roomSize / 2, 0)); mesh.Add(plane); //rotate plane to create box mesh.Add(plane.Transform(new Rotation3D(Axis.Z, 90f))); mesh.Add(plane.Transform(new Rotation3D(Axis.Z, 180f))); mesh.Add(plane.Transform(new Rotation3D(Axis.Z, 270f))); mesh.Add(plane.Transform(new Rotation3D(Axis.X, 90f))); mesh.Add(plane.Transform(new Rotation3D(Axis.X, -90f))); var sphere = Meshes.CreateSphere(1); sphere.SetConstantUV(new Vector2(0, 0)); mesh.Add(sphere); var suzanne = contentLoader.Load <DefaultMesh>("suzanne"); mesh.Add(suzanne.Transform(new Translation3D(2, 2, -2))); geometry = VAOLoader.FromMesh(mesh, shaderProgram); }
public DeferredRenderer(IContentLoader contentLoader, IRenderState renderState) { renderState.Set <DepthTest>(new DepthTest(true)); GL.Enable(EnableCap.CullFace); GL.Enable(EnableCap.Blend); GL.CullFace(CullFaceMode.Back); this.renderState = renderState; this.contentLoader = contentLoader; deferredParticleShader = contentLoader.Load <IShaderProgram>("deferred_particle.*"); shadowMapShaderParticle = contentLoader.Load <IShaderProgram>("shadowMapParticle.*"); shadowLightViewShaderParticle = contentLoader.Load <IShaderProgram>("shadowLightViewParticle.*"); deferredGeometryShader = contentLoader.Load <IShaderProgram>("deferred_geometry.*"); deferredPost = contentLoader.LoadPixelShader("deferred_post"); pointLightShader = contentLoader.Load <IShaderProgram>("def_pointLight.*"); shadowMapShader = contentLoader.Load <IShaderProgram>("shadowMap.*"); shadowLightViewShader = contentLoader.Load <IShaderProgram>("shadowLightView.*"); var lmesh = Meshes.CreateSphere(1, 2); pointLightSphere = VAOLoader.FromMesh(lmesh, pointLightShader); }
public SphereCut(IContentLoader contentLoader, float size) { _sphereCutProgram = contentLoader.Load <IShaderProgram>("imageOnGeometry.*"); var sphere = Meshes.CreateSphere(size, 5).SwitchHandedness(); _sphereGeometry = VAOLoader.FromMesh(sphere, _sphereCutProgram); }
private static VAO CreateMesh(Shader shader) { Mesh mesh = Meshes.CreateSphere(0.03f, 2); var vao = new VAO(); vao.SetAttribute(shader.GetAttributeLocation("position"), mesh.positions.ToArray(), VertexAttribPointerType.Float, 3); vao.SetAttribute(shader.GetAttributeLocation("normal"), mesh.normals.ToArray(), VertexAttribPointerType.Float, 3); vao.SetID(mesh.ids.ToArray(), PrimitiveType.Triangles); return(vao); }
private void UpdateGeometry(Shader shader) { var mesh = new Mesh(); var sphere = Meshes.CreateSphere(1, 4); mesh.Add(sphere); var suzanne = Obj2Mesh.FromObj(Resourcen.suzanne); mesh.Add(suzanne.Transform(System.Numerics.Matrix4x4.CreateTranslation(2, 2, -2))); geometry = VAOLoader.FromMesh(mesh, shader); }
public MainVisual(IRenderState renderState, IContentLoader contentLoader) { renderState.Set(new DepthTest(true)); renderState.Set(new FaceCullingModeState(FaceCullingMode.BACK_SIDE)); shaderProgram = contentLoader.Load <IShaderProgram>("shader.*"); var mesh = Meshes.CreateSphere(0.03f, 2); #if SOLUTION mesh = contentLoader.Load <DefaultMesh>("suzanne").Transform(Transformation.Scale(0.03f)); #endif geometry = VAOLoader.FromMesh(mesh, shaderProgram); InitParticles(); }
public void ShaderChanged(string name, Shader shader) { if (ShaderName != name) { return; } if (ReferenceEquals(shader, null)) { return; } var sphere = Meshes.CreateSphere(1, 4); var envSphere = sphere.SwitchTriangleMeshWinding(); envSphere.Add(sphere); geometry = VAOLoader.FromMesh(envSphere, shader); }
public MainVisual(IRenderState renderState, IContentLoader contentLoader) { renderState.Set(new DepthTest(true)); fboShadowMap.Texture.Filter = TextureFilterMode.Nearest; shaderProgram = contentLoader.Load <IShaderProgram>("shadowMap.*"); var mesh = Meshes.CreatePlane(10, 10, 10, 10); var sphere = Meshes.CreateSphere(0.5f, 2); sphere.SetConstantUV(new Vector2(0.5f, 0.5f)); mesh.Add(sphere.Transform(Transformation.Translation(0, 2, -2))); mesh.Add(sphere.Transform(Transformation.Translation(0, 2, 0))); mesh.Add(sphere.Transform(Transformation.Translation(2, 2, -1))); geometry = VAOLoader.FromMesh(mesh, shaderProgram); shaderProgramDepth = contentLoader.Load <IShaderProgram>("depth.*"); //todo: radeon cards created errors with geometry bound to one shader and used in other shaders because of binding id changes }
public Skybox(IContentLoader contentLoader, float size, string textureName) { _skyboxProgram = contentLoader.Load <IShaderProgram>("sky.*"); ITexture2D[] textures = new ITexture2D[6]; for (int i = 0; i < 6; i++) { textures[i] = contentLoader.Load <ITexture2D>(textureName + Endings[i]); } _cubeFbo = new CubeMapFBO(textures[0].Width); CreateMap(textures); var sphere = Meshes.CreateSphere(size).SwitchHandedness(); _sphereGeometry = VAOLoader.FromMesh(sphere, _skyboxProgram); }
private void UpdateGeometry(Shader shader) { Mesh mesh = Meshes.CreateSphere(0.03f, 2); geometry = VAOLoader.FromMesh(mesh, shader); //per instance attributes var rnd = new Random(12); Func <float> Rnd01 = () => (float)rnd.NextDouble(); Func <float> RndCoord = () => (Rnd01() - 0.5f) * 2.0f; var instancePositions = new Vector3[instanceCount]; for (int i = 0; i < instanceCount; ++i) { instancePositions[i] = new Vector3(RndCoord(), RndCoord(), RndCoord()); } geometry.SetAttribute(shader.GetAttributeLocation("instancePosition"), instancePositions, VertexAttribPointerType.Float, 3, true); //todo students: add per instance attribute speed here }
public MainVisual(IRenderState renderState, IContentLoader contentLoader) { this.renderState = renderState; var shaderMaterial = contentLoader.Load <IShaderProgram>("material.*"); var plane = Meshes.CreatePlane(4, 4, 1, 1); meshVisuals.Add(new MeshVisual(plane, shaderMaterial)); var instanceMesh = contentLoader.Load <DefaultMesh>("suzanne").Transform(Transformation.Scale(0.03f)); var instanceData = CreateInstancePositionMaterial(20, 20); var suzanneInstances = VAOLoader.FromMesh(instanceMesh, shaderMaterial); suzanneInstances.SetAttribute(shaderMaterial.GetResourceLocation(ShaderResourceType.Attribute, nameof(instanceData)), instanceData, true); meshVisuals.Add(new MeshVisual(suzanneInstances, shaderMaterial)); var shaderLighting = contentLoader.Load <IShaderProgram>("lighting.*"); var lightMesh = Meshes.CreateSphere(1f, 2); // either make it bigger or you need good subdivision to avoid border artifacts var lightGeometry = VAOLoader.FromMesh(lightMesh, shaderLighting); lightGeometry.SetAttribute(shaderLighting.GetResourceLocation(ShaderResourceType.Attribute, "lightData"), instanceData, true); lightsVisual = new MeshVisual(lightGeometry, shaderLighting); }
public MainVisual(IRenderState renderState, IContentLoader contentLoader) { renderState.Set(new ClearColorState(1, 1, 1, 1)); renderState.Set(BoolState <IDepthState> .Enabled); renderState.Set(BoolState <IBackfaceCullingState> .Enabled); envMap = contentLoader.Load <ITexture2D>("beach"); envMap.WrapFunction = TextureWrapFunction.MirroredRepeat; envMap.Filter = TextureFilterMode.Linear; sphereTex = contentLoader.Load <ITexture2D>("hatefield1"); sphereTex.WrapFunction = TextureWrapFunction.MirroredRepeat; sphereTex.Filter = TextureFilterMode.Linear; shaderProgram = contentLoader.Load <IShaderProgram>("envMapping.*"); var sphere = Meshes.CreateSphere(1, 4); var envSphere = sphere.SwitchTriangleMeshWinding(); var refSphere = Meshes.CreateSphere(.1f, 4).Transform(new Translation3D(new Vector3(-.1f, 0, 0))); var refractSphere = Meshes.CreateSphere(.1f, 4).Transform(new Translation3D(new Vector3(.1f, 0, 0))); geometry = VAOLoader.FromMesh(envSphere, shaderProgram); geometry.SetAttribute(shaderProgram.GetResourceLocation(ShaderResourceType.Attribute, "specularity"), new[] { 0.0f }, VertexAttribPointerType.Float, 1, true); geometry.SetAttribute(shaderProgram.GetResourceLocation(ShaderResourceType.Attribute, "translucency"), new[] { 0.0f }, VertexAttribPointerType.Float, 1, true); geometry.SetAttribute(shaderProgram.GetResourceLocation(ShaderResourceType.Attribute, "refractionIndex"), new[] { 1.0f }, VertexAttribPointerType.Float, 1, true); geometryRef = VAOLoader.FromMesh(refSphere, shaderProgram); geometryRef.SetAttribute(shaderProgram.GetResourceLocation(ShaderResourceType.Attribute, "specularity"), new[] { .2f }, VertexAttribPointerType.Float, 1, true); geometryRef.SetAttribute(shaderProgram.GetResourceLocation(ShaderResourceType.Attribute, "translucency"), new[] { 0.0f }, VertexAttribPointerType.Float, 1, true); geometryRef.SetAttribute(shaderProgram.GetResourceLocation(ShaderResourceType.Attribute, "refractionIndex"), new[] { 1.0f }, VertexAttribPointerType.Float, 1, true); geometryRefract = VAOLoader.FromMesh(refractSphere, shaderProgram); geometryRefract.SetAttribute(shaderProgram.GetResourceLocation(ShaderResourceType.Attribute, "specularity"), new[] { .0f }, VertexAttribPointerType.Float, 1, true); geometryRefract.SetAttribute(shaderProgram.GetResourceLocation(ShaderResourceType.Attribute, "translucency"), new[] { 1.0f }, VertexAttribPointerType.Float, 1, true); geometryRefract.SetAttribute(shaderProgram.GetResourceLocation(ShaderResourceType.Attribute, "refractionIndex"), new[] { 1.6f }, VertexAttribPointerType.Float, 1, true); }
public void ShaderChanged(string name, Shader shader) { if (ShaderName == name) { this.shaderObject = shader; if (ReferenceEquals(shader, null)) { return; } // cloud // cloud needs to be translated higher to "get" the (beginning) light from below Mesh cloudMesh = Obj2Mesh.FromObj(Resourcen.cloud); this.cloud = VAOLoader.FromMesh(cloudMesh, shader); // table Mesh tableClothMesh = Obj2Mesh.FromObj(Resourcen.tableCloth); this.tableCloth = VAOLoader.FromMesh(tableClothMesh, shader); // table top Mesh tableMesh = Obj2Mesh.FromObj(Resourcen.table); this.table = VAOLoader.FromMesh(tableMesh, shader); // candle Mesh candleMesh = Obj2Mesh.FromObj(Resourcen.candle); this.candle = VAOLoader.FromMesh(candleMesh, shader); // plate Mesh plateMesh = Obj2Mesh.FromObj(Resourcen.plate); this.plate = VAOLoader.FromMesh(plateMesh, shader); // grape plate var xform = new Transformation(); xform.ScaleGlobal(new System.Numerics.Vector3(.8f)); Mesh grapePlateMesh = Obj2Mesh.FromObj(Resourcen.plate); this.grapePlate = VAOLoader.FromMesh(grapePlateMesh.Transform(xform), shader); // wine bottle Mesh wineBottleMesh = Obj2Mesh.FromObj(Resourcen.wineBottle); this.wineBottle = VAOLoader.FromMesh(wineBottleMesh, shader); // wine bottle label Mesh wineBottleLabelMesh = Obj2Mesh.FromObj(Resourcen.wineBottleLabel); this.wineBottleLabel = VAOLoader.FromMesh(wineBottleLabelMesh, shader); // wine bottle shutter Mesh wineBottleShutterMesh = Obj2Mesh.FromObj(Resourcen.wineBottleShutter); this.wineBottleShutter = VAOLoader.FromMesh(wineBottleShutterMesh, shader); // grapes Mesh grapesMesh = Obj2Mesh.FromObj(Resourcen.grapes); this.grapes = VAOLoader.FromMesh(grapesMesh, shader); // knife left Mesh knifeLeftMesh = Obj2Mesh.FromObj(Resourcen.knife); this.knifeLeft = VAOLoader.FromMesh(knifeLeftMesh, shader); // knife right var xform_ = new Transformation(); xform_.RotateYGlobal(180f); Mesh knifeRightMesh = Obj2Mesh.FromObj(Resourcen.knife); this.knifeRight = VAOLoader.FromMesh(knifeRightMesh.Transform(xform_), shader); // fork left Mesh forkLeftMesh = Obj2Mesh.FromObj(Resourcen.fork); this.forkLeft = VAOLoader.FromMesh(forkLeftMesh, shader); // fork right Mesh forkRightMesh = Obj2Mesh.FromObj(Resourcen.fork); this.forkRight = VAOLoader.FromMesh(forkRightMesh.Transform(xform_), shader); // environment sphere var sphere = Meshes.CreateSphere(6, 4); var envSphere = sphere.SwitchTriangleMeshWinding(); this.environment = VAOLoader.FromMesh(envSphere, shader); } else if (ShaderShadowName == name) { this.shaderShadow = shader; if (ReferenceEquals(shaderObject, null)) { return; } } }
/// <summary>Builds a model for the joint end basing on the procedural configuration.</summary> /// <param name="modelName">Joint transform name.</param> /// <param name="config">Joint configuration from the part's config.</param> protected virtual void CreateJointEndModels(string modelName, JointConfig config) { // FIXME: Prefix the model name with the renderer name. // Make or get the root. Transform root = null; if (config.type == PipeEndType.PrefabModel) { root = Hierarchy.FindTransformByPath(partModelTransform, config.modelPath); if (root != null) { root.parent = partModelTransform; // We need the part's model to be the root. var partAttach = new GameObject(PartJointTransformName).transform; Hierarchy.MoveToParent(partAttach, root, newPosition: config.partAttachAt.pos, newRotation: config.partAttachAt.rot); var pipeAttach = new GameObject(PipeJointTransformName); Hierarchy.MoveToParent(pipeAttach.transform, root, newPosition: config.pipeAttachAt.pos, newRotation: config.pipeAttachAt.rot); } else { HostedDebugLog.Error(this, "Cannot find model: {0}", config.modelPath); config.type = PipeEndType.Simple; // Fallback. } } if (root == null) { root = new GameObject().transform; Hierarchy.MoveToParent(root, partModelTransform); var partJoint = new GameObject(PartJointTransformName).transform; Hierarchy.MoveToParent(partJoint, root); partJoint.rotation = Quaternion.LookRotation(Vector3.forward); if (config.type == PipeEndType.ProceduralModel) { // Create procedural models at the point where the pipe connects to the part's node. var material = CreateMaterial( GetTexture(config.texture), mainTexNrm: config.textureNrm != "" ? GetTexture(config.textureNrm) : null); var sphere = Meshes.CreateSphere(config.sphereDiameter, material, root, colliderType: Colliders.PrimitiveCollider.Shape); sphere.name = PipeJointTransformName; sphere.transform.rotation = Quaternion.LookRotation(Vector3.back); RescaleTextureToLength(sphere, samplesPerMeter: config.textureSamplesPerMeter); if (Mathf.Abs(config.sphereOffset) > float.Epsilon) { sphere.transform.localPosition += new Vector3(0, 0, config.sphereOffset); if (config.armDiameter > float.Epsilon) { var arm = Meshes.CreateCylinder( config.armDiameter, config.sphereOffset, material, root, colliderType: Colliders.PrimitiveCollider.Shape); arm.transform.localPosition += new Vector3(0, 0, config.sphereOffset / 2); arm.transform.LookAt(sphere.transform.position); RescaleTextureToLength(arm, samplesPerMeter: config.textureSamplesPerMeter); } } } else { // No extra models are displayed at the joint, just attach the pipe to the part's node. if (config.type != PipeEndType.Simple) { // Normally, this error should never pop up. HostedDebugLog.Error(this, "Unknown joint type: {0}", config.type); } var pipeJoint = new GameObject(PipeJointTransformName); Hierarchy.MoveToParent(pipeJoint.transform, root); pipeJoint.transform.rotation = Quaternion.LookRotation(Vector3.back); } } Colliders.UpdateColliders(root.gameObject, isPhysical: config.colliderIsPhysical); root.gameObject.SetActive(false); root.name = modelName; }
/// <summary>Builds a model for the joint end basing on the configuration.</summary> /// <param name="node">The node to setup.</param> /// <param name="alignTo"> /// The object to align the conenctor to. If it's <c>null</c>, then the model will be parked. /// </param> protected virtual void UpdateJointNode(ModelPipeEndNode node, Transform alignTo) { var config = node.config; var makeProceduralModels = alignTo != null || !config.parkPrefabOnly; // Return the models back to the owner part to make the search working properly. if (node.rootModel != null) { node.AlignToTransform(null); } node.parkRootObject = partModelTransform; // Create basic setup. var nodeName = ModelBasename + "-pipeNode" + node.name; node.rootModel = partModelTransform.Find(nodeName) ?? new GameObject(nodeName).transform; node.rootModel.parent = partModelTransform; node.partAttach = node.rootModel.Find(PartJointTransformName) ?? new GameObject(PartJointTransformName).transform; Hierarchy.MoveToParent(node.partAttach, node.rootModel, newPosition: Vector3.zero, newRotation: Quaternion.LookRotation(Vector3.back)); node.pipeAttach = node.rootModel.Find(PipeJointTransformName) ?? new GameObject(PipeJointTransformName).transform; Hierarchy.MoveToParent(node.pipeAttach, node.rootModel, newPosition: Vector3.zero, newRotation: Quaternion.LookRotation(Vector3.forward)); // Add a pipe attachment sphere if set. const string sphereName = "pipeSphere"; var sphere = node.pipeAttach.Find(sphereName); if (config.sphereDiameter > float.Epsilon && makeProceduralModels) { if (sphere == null) { sphere = Meshes.CreateSphere(config.sphereDiameter, pipeMaterial, node.pipeAttach, colliderType: Colliders.PrimitiveCollider.Shape).transform; sphere.name = sphereName; sphere.rotation = Quaternion.LookRotation(node.partAttach.up, node.partAttach.forward); } sphere.GetComponent <Renderer>().sharedMaterial = pipeMaterial; // For performance. RescalePipeTexture(sphere, sphere.localScale.z * config.sphereDiameter * 2.0f); } else if (sphere != null) { Hierarchy.SafeDestory(sphere); } // Parking position, if defined. var parkObjectName = ModelBasename + "-park" + node.name; var parkAttach = partModelTransform.Find(parkObjectName); if (config.parkAttachAt != null) { node.parkAttach = parkAttach ?? new GameObject(parkObjectName).transform; Hierarchy.MoveToParent(node.parkAttach, partModelTransform, newPosition: config.parkAttachAt.pos, newRotation: config.parkAttachAt.rot); } else if (parkAttach != null) { Hierarchy.SafeDestory(parkAttach); } // Place prefab between the part and the pipe if specified. if (!string.IsNullOrEmpty(config.modelPath)) { // The prefab model can move to the part's model, so make a unique name for it. const string prefabName = "prefabConnector"; var prefabModel = node.rootModel.Find(prefabName) ?? Hierarchy.FindTransformByPath(partModelTransform, config.modelPath); if (prefabModel != null) { prefabModel.gameObject.SetActive(true); prefabModel.name = prefabName; prefabModel.parent = node.rootModel; prefabModel.rotation = node.partAttach.rotation * config.modelPartAttachAt.rot.Inverse(); prefabModel.position = node.partAttach.TransformPoint(config.modelPartAttachAt.pos); node.pipeAttach.rotation = prefabModel.rotation * config.modelPipeAttachAt.rot; node.pipeAttach.position = prefabModel.TransformPoint(config.modelPipeAttachAt.pos); } else { HostedDebugLog.Error(this, "Cannot find prefab model: {0}", config.modelPath); } } // The offset is intended for the sphere/arm models only. if (makeProceduralModels) { node.pipeAttach.localPosition += new Vector3(0, 0, config.sphereOffset); } // Add arm pipe. const string armName = "sphereArm"; var arm = node.pipeAttach.Find(armName); if (config.armDiameter > float.Epsilon && config.sphereOffset > float.Epsilon && makeProceduralModels) { if (arm == null) { arm = Meshes.CreateCylinder(config.armDiameter, config.sphereOffset, pipeMaterial, node.pipeAttach, colliderType: Colliders.PrimitiveCollider.Shape).transform; arm.name = armName; } arm.GetComponent <Renderer>().sharedMaterial = pipeMaterial; // For performance. arm.transform.localPosition = new Vector3(0, 0, -config.sphereOffset / 2); arm.transform.localRotation = Quaternion.LookRotation(Vector3.forward); RescalePipeTexture(arm.transform, arm.localScale.z * config.sphereOffset); } else if (arm != null) { Hierarchy.SafeDestory(arm); } // Adjust to the new target. node.AlignToTransform(alignTo); }
private List <Entity> GetGeometry(DeferredRenderer renderer) { IShaderProgram defaultShader = renderer.GetShader(DeferredRenderer.DrawableType.deferredDefaultMesh); List <Entity> res = new List <Entity>(); float islandScale = 30f; var islePlane = Meshes.CreatePlane(30, 30, 120, 120).Transform(Transformation.Translation(0, islandScale / 2, 0)); Renderable isle = ContentFactory.GetDefaultRenderable(renderer, islePlane); ITexture2D isleAlbedo = contentLoader.Load <ITexture2D>("terrain.png"); isleAlbedo.Filter = TextureFilterMode.Linear; //ITexture2D isleNormal = contentLoader.Load<ITexture2D>("normalTest1.jpg"); isle.SetAlbedoTexture(isleAlbedo); //isle.SetNormalMap(isleNormal); ITexture2D isleHeightmap = contentLoader.Load <ITexture2D>("hmapUnity.png"); isle.SetHeightMap(isleHeightmap); isle.heightScaleFactor = islandScale; Entity isleEntity = new Entity(); isleEntity.name = "isle"; isleEntity.renderable = isle; Terrain isleTerrain = new Terrain(contentLoader, "hmapUnity.png", islandScale, 30, 30); isleTerrain.transform.position = new Vector3(0, islandScale / 2, 0); var waterplane = Meshes.CreatePlane(100, 100, 225, 225).Transform(Transformation.Translation(0, 1f, 0)); VAO waterDrawable = renderer.GetDrawable(waterplane, DeferredRenderer.DrawableType.deferredDefaultMesh); Renderable water = ContentFactory.GetDefaultRenderable(renderer, waterplane); ITexture2D waterEnvironment = contentLoader.Load <ITexture2D>("sky_low.jpg"); water.SetEnvironmentMap(waterEnvironment); water.reflectivity = 1; //water.SetAlbedoTexture(isleAlbedo); Entity waterEntity = new Entity(); waterEntity.name = "water"; waterEntity.renderable = water; var grassPlane = Meshes.CreatePlane(1, 1, 2, 2).Transform(Transformation.Rotation(-90, Axis.X)); Renderable grass = ContentFactory.GetDefaultRenderable(renderer, grassPlane); grass.faceCullingMode = FaceCullingMode.NONE; ITexture2D grassAlbedo = contentLoader.Load <ITexture2D>("Grass_512_albedo.tif"); ITexture2D grassAlpha = contentLoader.Load <ITexture2D>("tGrass_512_alpha.tif"); grass.SetAlbedoTexture(grassAlbedo); grass.SetAlphaMap(grassAlpha); //Entity grassEntity = new Entity(); //grassEntity.renderable = grass; Vector3[] spawnPositions = { new Vector3(-0.1f, 7.1f, 2.5f), new Vector3(-3.5f, 7.1f, -1.5f), new Vector3(6f, 7.1f, 2.5f), new Vector3(6f, 7.1f, -1.5f),new Vector3(5f,7.1f, -6f), new Vector3(1f, 7.1f, -8f), new Vector3(-3f, 7.1f, -8f) }; float[] radius = { 2f, 1.9f, 2f, 2f, 2f, 2f, 2f }; int[] amountGrass = { 50, 60, 50, 60, 60, 60, 60 }; Range3D scaleRange = new Range3D(new Vector3(0.5f), new Vector3(1.5f)); TerrainLayer layer = new TerrainLayer(isleTerrain, grass); for (int i = 0; i < spawnPositions.Length; i++) { SphericalTerrainSpawner grassSpawner = new SphericalTerrainSpawner(spawnPositions[i], radius[i], amountGrass[i]); grassSpawner.randomScaleRange = scaleRange; layer.AddSpawner(grassSpawner); } layer.SpawnElements(); res.Add(layer); var skysphere = Meshes.CreateSphere(60, 2); skysphere.SwitchTriangleMeshWinding(); Renderable skydome = ContentFactory.GetDefaultRenderable(renderer, skysphere); skydome.faceCullingMode = FaceCullingMode.FRONT_SIDE; skydome.unlit = 1; skydome.SetAlbedoTexture(waterEnvironment); Entity skyEntity = new Entity(); skyEntity.renderable = skydome; skyEntity.name = "skydome"; var msphere = Meshes.CreateSphere(1, 2).Transform(Transformation.Translation(0, 2, 0)); Renderable sphere = ContentFactory.GetDefaultRenderable(renderer, msphere); VAO spVao = renderer.GetDrawable(msphere, DeferredRenderer.DrawableType.deferredDefaultMesh); sphere.SetEnvironmentMap(waterEnvironment); Entity spEntity = new Entity(); spEntity.name = "sphere"; spEntity.renderable = sphere; //res.Add(grassEntity); res.Add(isleEntity); res.Add(waterEntity); //res.Add(spEntity); res.Add(skyEntity); return(res); }