void Awake()
{
_meshRenderer = _gameObjectWithRenderer.GetComponent <MeshRenderer>();
if (_meshRenderer != null)
{
_rendererType = RendererType.Mesh;
_enable = new Material[2] {
_meshRenderer.material, _material
};
_disable = new Material[1] {
_meshRenderer.material
};
}
else
{
_skinMeshRenderer = _gameObjectWithRenderer.GetComponent <SkinnedMeshRenderer>();
if (_skinMeshRenderer != null)
{
_rendererType = RendererType.SkinMesh;
_enable = new Material[2] {
_skinMeshRenderer.material, _material
};
_disable = new Material[1] {
_skinMeshRenderer.material
};
}
}
}
private void ValidateGeneratedSql(RendererType rendererType)
{
if (string.IsNullOrEmpty(ctrlSql.Text))
{
return;
}
string strippedOriginalSql = StripSql(ctrlSql.Text);
string strippedSqlFromSqlOm = StripSql(ctrlSqlOmToSql.Text);
bool sqlFromSqlOmIsValid = strippedOriginalSql.Equals(strippedSqlFromSqlOm);
if (sqlFromSqlOmIsValid)
{
ctrlOperationResult.Text = "Success";
ctrlOperationResult.ForeColor = Color.Green;
}
else if (string.IsNullOrEmpty(ctrlSqlOmToSql.Text))
{
ctrlOperationResult.Text = "Error";
ctrlOperationResult.ForeColor = Color.Red;
}
else
{
ctrlOperationResult.Text = "Warning";
ctrlOperationResult.ForeColor = Color.Orange;
}
ctrlOperationResult.Text += $" ({rendererType.ToString()})";
}
/// <summary>
/// 基于文件路径的构造函数
/// </summary>
internal MyLayer(string layerpath)
{
if (Path.GetExtension(layerpath) == ".shp")
{
Shapefile shp = new Shapefile(layerpath);
layerName = shp.Name;
dataType = shp.DataType;
spaceData = new MySpaceData(shp);
renderer = new SimpleRenderer(dataType);
rendertype = RendererType.SimpleRenderer;
hastext = false;
Visible = true;
filepath = shp.FilePath;
}
else
{
CosmosGisVector cgv = new CosmosGisVector(layerpath);
layerName = cgv.Name;
dataType = cgv.SpaceDataType;
spaceData = new MySpaceData(cgv);
renderer = new SimpleRenderer(dataType);
rendertype = RendererType.SimpleRenderer;
hastext = false;
Visible = true;
filepath = cgv.FilePath;
}
/*///TODO
* spaceData = new MySpaceData("");
* layerName = Path.GetFileNameWithoutExtension(fileName);
* dataType = spaceData.DataType;
* this.Visible = true;*/
}
public Spec(string name, string fileName, string extensions, RendererType rendererType = RendererType.Html)
{
Name = name;
Path = SpecificationsDirectory;
if (rendererType == RendererType.Html)
{
Path += "Specs";
}
else if (rendererType == RendererType.Normalize)
{
Path += "NormalizeSpecs";
}
else if (rendererType == RendererType.PlainText)
{
Path += "PlainTextSpecs";
}
else if (rendererType == RendererType.Roundtrip)
{
Path += "RoundtripSpecs";
}
Path += "/" + fileName;
OutputPath = System.IO.Path.ChangeExtension(Path, "generated.cs");
Extensions = extensions;
RendererType = rendererType;
}
} //END GetDefaultStartValue
//--------------------------------------------//
public void Play<T>( T Component, Color startColor, Color endColor, AnimationCurve easeCurve, float length, float delay, bool loop, UnityEvent onCompleteOrLoop )
//--------------------------------------------//
{
//Setup the object and its values for the tween
if( Component != null && IsValidComponent(Component) )
{
rendererType = GetType( Component );
SetComponentToValue( Component, rendererType );
this.startColor = startColor;
this.endColor = endColor;
Setup( easeCurve, length, delay, loop, onCompleteOrLoop );
//Debug.Log( "bxrTweenColor.cs Play(), about to call base.Play()" );
//Now that the values are setup, call the Play() from the base class to begin the tween
base.Play();
}
else
{
if( Component == null )
{
Debug.Log("bxrTweenColor.cs Play() Unable to Play Tween, Component variable is null");
}
else if( Component != null && !IsValidComponent(Component) )
{
Debug.Log("bxrTweenColor.cs Play() Unable to Play Tween, Component variable is not null but is not a valid component or object that can be tweened.\n Component type = " + Component.GetType() );
}
}
} //END Play
public ISymbol this[RendererType rendererType]
{
get
{
try
{
IFeatureRenderer2 r = _renderers[(int)rendererType] as IFeatureRenderer2;
if (r != null)
{
return(r.Symbol);
}
}
catch
{
}
return(null);
}
set
{
try
{
IFeatureRenderer2 r = _renderers[(int)rendererType] as IFeatureRenderer2;
if (r != null && r.Symbol != value)
{
r.Symbol = value;
}
}
catch
{
}
}
}
// Use this for initialization
void Awake()
{
associatedChunkMeshCluster = null;
generateMeshWorkFunction = new BatchProcessor.WorkFunction(GenerateMeshThread);
meshGenerationState = MeshGenerationState.Waiting;
verticesList = new List <Vector3>();
uvList = new List <Vector2>();
trianglesList = new List <int>();
normalsList = new List <Vector3>();
colorList = new List <Color32>();
rendererType = RendererType.Solid;
// Load up our mesh double buffering
activeMesh = 0;
meshes = new Mesh[2];
rendererGameObjects = new GameObject[2];
int index = 0;
foreach (Transform child in transform)
{
rendererGameObjects[index] = child.gameObject;
rendererGameObjects[index].SetActive(false);
meshes[index] = child.gameObject.GetComponent <MeshFilter>().mesh;
meshes[index].Clear();
index++;
}
}
public void Setup(ChunkMeshCluster chunkMeshCluster, RendererType rendererType)
{
SetRendererType(rendererType);
if (rendererType == RendererType.Water)
{
// Water rendering requires that we overlap the meshes less, because of the transparency
blockMeshHalfSize = 0.5f + 0.00001f;
}
else
{
// The fractional part seals the mesh and prevents flickering
blockMeshHalfSize = 0.5f + 0.0005f;
}
if (chunkMeshCluster != null && chunkMeshCluster.chunk != null)
{
Vector3 position;
position.x = chunkMeshCluster.chunk.WorldPosition().x *Chunk.SIZE - 0.5f;
position.y = chunkMeshCluster.chunk.WorldPosition().y *Chunk.SIZE - 0.5f;
position.z = chunkMeshCluster.chunk.WorldPosition().z *Chunk.SIZE - 0.5f;
transform.position = position;
}
associatedChunkMeshCluster = chunkMeshCluster;
SetName();
}
public LWFObject()
{
rendererType = RendererType.CombinedMeshRenderer;
isAlive = true;
lwfLoadCallbacks = new LWFCallbacks();
lwfDestroyCallbacks = new LWFCallbacks();
}
/// <summary>
/// Activates logging to AWS CloudWatch
/// </summary>
/// <remarks>This overload is intended to be used via AppSettings integration.</remarks>
/// <param name="loggerConfiguration">The LoggerSinkConfiguration to register this sink with.</param>
/// <param name="logGroupName">The log group name to be used in AWS CloudWatch.</param>
/// <param name="accessKey">The access key to use to access AWS CloudWatch.</param>
/// <param name="secretAccessKey">The secret access key to use to access AWS CloudWatch.</param>
/// <param name="regionName">The system name of the region to which to write.</param>
/// <param name="logStreamNamePrefix">The log stream name prefix. Will use default log stream name if leave empty.</param>
/// <param name="rendererType">The renderer to be used to format the message.</param>
/// <param name="minimumLogEventLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="batchSizeLimit">The batch size to be used when uploading logs to AWS CloudWatch.</param>
/// <param name="period">The period to be used when a batch upload should be triggered.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"><paramref name="logGroupName"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="accessKey"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="secretAccessKey"/> is <see langword="null"/>.</exception>
public static LoggerConfiguration AmazonCloudWatch(
this LoggerSinkConfiguration loggerConfiguration,
string logGroupName,
string accessKey,
string secretAccessKey,
string regionName = null,
string logStreamNamePrefix = null,
RendererType rendererType = RendererType.DefaultRenderer,
LogEventLevel minimumLogEventLevel = CloudWatchSinkOptions.DefaultMinimumLogEventLevel,
int batchSizeLimit = CloudWatchSinkOptions.DefaultBatchSizeLimit,
TimeSpan?period = null)
{
ILogEventRenderer logEventRenderer = new DefaultLogEventRenderer();
if (rendererType == RendererType.JsonRenderer)
{
logEventRenderer = new JsonLogEventRenderer();
}
return(loggerConfiguration.AmazonCloudWatch(logGroupName,
accessKey,
secretAccessKey,
regionName,
logStreamNamePrefix,
logEventRenderer,
minimumLogEventLevel,
batchSizeLimit,
period));
}
public void UpdatePoints()
{
if (scene.RenderingMode != rendererType)
{
switch (scene.RenderingMode)
{
case RendererType.Standard:
renderer = new StandardRenderer();
break;
case RendererType.Stereoscopic:
renderer = new StereoscopicRender();
break;
default:
renderer = new StandardRenderer();
break;
}
renderer.SetImageContent(targetImage);
renderer.Resize(imageSize.X, imageSize.Y);
rendererType = scene.RenderingMode;
scene.CurrentRenderer = renderer;
}
renderer.BeforeRendering(scene);
scene.Render(renderer);
renderer.AfterRendering(scene);
}
private ChunkMesh GetExistingChunkMesh(ChunkMeshCluster chunkMeshCluster, RendererType rendererType)
{
availableChunkMeshCount--;
ChunkMesh returnChunkMesh = availableChunkMeshes.Pop();
returnChunkMesh.Setup(chunkMeshCluster, rendererType);
return(returnChunkMesh);
}
public void SignalGenerationComplete(RendererType rendererType)
{
chunkMeshStates[(int)rendererType] = ChunkMeshState.GenerationComplete;
if (GenerationIsComplete())
{
chunk.SetLoadState(ChunkLoadState.MeshCalculationComplete);
}
}
public WPFWindow(IController controller, IRenderer renderer, RendererType rendererType)
{
if (controller == null) throw new ArgumentNullException("controller");
_controller = controller;
_renderer = renderer;
_rendererType = rendererType;
}
public FormFeatureRenderers(IFeatureLayer layer, RendererType type)
{
InitializeComponent();
btnOK.Enabled = false;
_type = type;
_layer = layer;
MakeTree();
}
public void SignalFinished(RendererType rendererType)
{
chunkMeshStates[(int)rendererType] = ChunkMeshState.Done;
if (IsFinished())
{
SetVisible(chunk.IsVisible());
chunk.SetLoadState(ChunkLoadState.Done);
}
}
public TVEElementDrawerData(ElementType elementType, ElementLayer elementLayer, RendererType rendererType, GameObject gameobject, Mesh mesh, Renderer renderer)
{
this.elementType = elementType;
this.elementLayer = elementLayer;
this.rendererType = rendererType;
this.gameobject = gameobject;
this.mesh = mesh;
this.renderer = renderer;
}
protected virtual void Update()
{
// GetComponents
if (rendererType != _rendererTypeTemp)
{
AtualizeRenderers();
_rendererTypeTemp = rendererType;
}
}
private void SetRenderType(RendererType rendererType)
{
OptionsRenderersD3D.Checked = false;
OptionsRenderersShader.Checked = false;
OptionsRenderersGDI.Checked = false;
var wasHalted = _gbaManager.Halted;
_gbaManager.Halt();
if (_device != null)
{
_device.Dispose();
}
_rendererType = rendererType;
switch (_rendererType)
{
case RendererType.D3DRenderer:
OptionsRenderersD3D.Checked = true;
InitializeD3D();
_gbaManager.VideoManager.Presenter = RenderD3D;
var renderer = new Renderer();
renderer.Initialize(null);
_gbaManager.VideoManager.Renderer = renderer;
break;
case RendererType.GdiRenderer:
OptionsRenderersGDI.Checked = true;
new Bitmap(240, 160, PixelFormat.Format32bppRgb);
break;
case RendererType.ShaderRenderer:
OptionsRenderersShader.Checked = true;
InitializeD3D();
_gbaManager.VideoManager.Presenter = RenderShader;
_gbaManager.Memory.EnableVramUpdating();
var shaderRenderer = new ShaderRenderer();
shaderRenderer.Initialize(_device);
_gbaManager.VideoManager.Renderer = shaderRenderer;
break;
}
if (!wasHalted)
{
_gbaManager.Resume();
}
}
public RenderingContext(SceneData lineData, Image image)
{
targetImage = image;
rendererType = lineData.RenderingMode;
renderer.SetImageContent(image);
scene = lineData;
Thickness = 1;
SelectedItemThickness = 3;
LineColor = Colors.Gold;
}
public WPFWindow(IController controller, IRenderer renderer, RendererType rendererType)
{
if (controller == null)
{
throw new ArgumentNullException("controller");
}
_controller = controller;
_renderer = renderer;
_rendererType = rendererType;
}
public ScriptableRendererData LoadBuiltinRendererData(RendererType type = RendererType.ForwardRenderer)
{
#if UNITY_EDITOR
EditorUtility.SetDirty(this);
return(m_RendererDataList[0] = CreateRendererAsset("Assets/ForwardRenderer.asset", type, false));
#else
m_RendererDataList[0] = null;
return(m_RendererDataList[0]);
#endif
}
/// <summary>
/// Set target Renderer component.
/// </summary>
/// <param name="renderer">target renderer component</param>
/// <returns></returns>
public Davinci into(Renderer renderer)
{
if (enableLog)
{
Debug.Log("[Davinci] Target as Renderer set : " + renderer);
}
rendererType = RendererType.renderer;
this.targetObj = renderer.gameObject;
return(this);
}
/// <summary>
/// Set target Image component.
/// </summary>
/// <param name="image">target Unity UI image component</param>
/// <returns></returns>
public Davinci into(Image image)
{
if (enableLog)
{
Debug.Log("[Davinci] Target as UIImage set : " + image);
}
rendererType = RendererType.uiImage;
this.targetObj = image.gameObject;
return(this);
}
static ScriptableRendererData CreateRendererData(RendererType type)
{
switch (type)
{
case RendererType.ForwardRenderer:
return(CreateInstance <ForwardRendererData>());
default:
return(CreateInstance <ForwardRendererData>());
}
}
/// <summary>
/// Set target Raw Image component.
/// </summary>
/// <param name="renderer">target renderer component</param>
/// <returns></returns>
public Azzy into(RawImage rawImage)
{
if (enableLog)
{
Debug.Log("[Azzy] Target as Renderer set : " + rawImage);
}
rendererType = RendererType.rawImage;
this.targetObj = rawImage.gameObject;
return(this);
}
/// <summary>
/// Set target Renderer component.
/// </summary>
/// <param name="spriteRenderer">target sprite renderer component</param>
/// <returns></returns>
public Davinci into(SpriteRenderer spriteRenderer)
{
if (enableLog)
{
Debug.Log("[Davinci] Target as SpriteRenderer set : " + spriteRenderer);
}
rendererType = RendererType.sprite;
this.targetObj = spriteRenderer.gameObject;
return(this);
}
/// <summary>
/// 基于CosmosGisVector的构造函数
/// </summary>
/// <param name="cgv">CosmosGisVector</param>
internal MyLayer(CosmosGisVector cgv)
{
layerName = cgv.Name;
dataType = cgv.SpaceDataType;
spaceData = new MySpaceData(cgv);
renderer = new SimpleRenderer(dataType);
rendertype = RendererType.SimpleRenderer;
hastext = false;
Visible = true;
filepath = cgv.FilePath;
}
/// <summary>
/// 基于Shapefile的构造函数
/// </summary>
/// <param name="shp">Shapefile</param>
internal MyLayer(Shapefile shp)
{
layerName = shp.Name;
dataType = shp.DataType;
spaceData = new MySpaceData(shp);
renderer = new SimpleRenderer(dataType);
rendertype = RendererType.SimpleRenderer;
hastext = false;
Visible = true;
filepath = shp.FilePath;
}
internal static ScriptableRendererData CreateRendererAsset(string path, RendererType type, bool relativePath = true)
{
ScriptableRendererData data = CreateRendererData(type);
string dataPath;
if (relativePath)
dataPath =
$"{Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path))}_Renderer{Path.GetExtension(path)}";
else
dataPath = path;
AssetDatabase.CreateAsset(data, dataPath);
return data;
}
static ScriptableRendererData CreateRendererData(RendererType type)
{
switch (type)
{
case RendererType.ForwardRenderer:
return(CreateInstance <ForwardRendererData>());
// Forward Renderer is the fallback renderer that works on all platforms
default:
return(CreateInstance <ForwardRendererData>());
}
}
public IRenderer CreateRenderer(RendererType type)
{
switch (type)
{
case RendererType.OpenGL:
return new OpenGLRenderer();
case RendererType.Direct3D:
return new Direct3DRenderer();
case RendererType.Composite:
return new CompositeRenderer();
default:
throw new ArgumentOutOfRangeException("type");
}
}
public LWFObject()
{
rendererType = RendererType.CombinedMeshRenderer;
isAlive = true;
lwfLoadCallbacks = new LWFCallbacks();
lwfDestroyCallbacks = new LWFCallbacks();
}
public void UseCombinedMeshRenderer()
{
rendererType = RendererType.CombinedMeshRenderer;
}
static void KeyboardHandle(byte key, int x, int y)
{
SceneCamera sceneCam = scene.Camera;
Vector dir = sceneCam.Target - sceneCam.Position;
float tar_posDist = dir.Magnitude3();
dir.Normalize3();
Vector right = Vector.Cross3(dir, sceneCam.Up);
float camSpeed = 10f;
Vector tempVec;
float turnSpeed = 0.01f;
if (key == (int)NumberKeys.One)
{
mode = RendererType.OpenGL;
Glut.glutPostRedisplay();
}
else if (key == (int)NumberKeys.Two)
{
mode = RendererType.Raytracer;
raytraceRenderer.ResetTracer();
transformationRenderer.ResetRenderer();
currentRenderer = raytraceRenderer;
Glut.glutPostRedisplay();
}
else if (key == (int)NumberKeys.Three)
{
mode = RendererType.RasterizerWireframe;
rendParams.WireFrame = true;
transformationRenderer.ResetRenderer();
currentRenderer = transformationRenderer;
Glut.glutPostRedisplay();
}
else if (key == (int)NumberKeys.Four)
{
mode = RendererType.Rasterizer;
rendParams.WireFrame = false;
transformationRenderer.ResetRenderer();
currentRenderer = transformationRenderer;
Glut.glutPostRedisplay();
}
else if (key == (byte)'w')
{
scene.Camera.Position += dir * camSpeed;
scene.Camera.Target += dir * camSpeed;
raytraceRenderer.ResetTracer();
transformationRenderer.ResetRenderer();
Glut.glutPostRedisplay();
}
else if (key == (byte)'s')
{
scene.Camera.Position -= dir * camSpeed;
scene.Camera.Target -= dir * camSpeed;
raytraceRenderer.ResetTracer();
transformationRenderer.ResetRenderer();
Glut.glutPostRedisplay();
}
else if (key == (byte)'a')
{
scene.Camera.Position -= right * camSpeed;
scene.Camera.Target -= right * camSpeed;
raytraceRenderer.ResetTracer();
transformationRenderer.ResetRenderer();
Glut.glutPostRedisplay();
}
else if (key == (byte)'d')
{
scene.Camera.Position += right * camSpeed;
scene.Camera.Target += right * camSpeed;
raytraceRenderer.ResetTracer();
transformationRenderer.ResetRenderer();
Glut.glutPostRedisplay();
}
else if (key == (byte)'i')
{
tempVec = dir + scene.Camera.Up * turnSpeed;
tempVec.Normalize3();
scene.Camera.Target = scene.Camera.Position + tempVec * tar_posDist;
scene.Camera.Up = Vector.Cross3(right, tempVec);
raytraceRenderer.ResetTracer();
transformationRenderer.ResetRenderer();
Glut.glutPostRedisplay();
}
else if (key == (byte)'k')
{
tempVec = dir - scene.Camera.Up * turnSpeed;
tempVec.Normalize3();
scene.Camera.Target = scene.Camera.Position + tempVec * tar_posDist;
scene.Camera.Up = Vector.Cross3(right, tempVec);
raytraceRenderer.ResetTracer();
transformationRenderer.ResetRenderer();
Glut.glutPostRedisplay();
}
else if (key == (byte)'j')
{
tempVec = dir - right * turnSpeed;
tempVec.Normalize3();
scene.Camera.Target = scene.Camera.Position + tempVec * tar_posDist;
raytraceRenderer.ResetTracer();
transformationRenderer.ResetRenderer();
Glut.glutPostRedisplay();
}
else if (key == (byte)'l')
{
tempVec = dir + right * turnSpeed;
tempVec.Normalize3();
scene.Camera.Target = scene.Camera.Position + tempVec * tar_posDist;
raytraceRenderer.ResetTracer();
transformationRenderer.ResetRenderer();
Glut.glutPostRedisplay();
}
else if (key == (byte)'x')
{
raytraceRenderer.renderingParameters.EnableRefractions = !raytraceRenderer.renderingParameters.EnableRefractions;
raytraceRenderer.ResetTracer();
transformationRenderer.ResetRenderer();
Glut.glutPostRedisplay();
}
else if (key == (byte)'z')
{
raytraceRenderer.renderingParameters.EnableShadows = !raytraceRenderer.renderingParameters.EnableShadows;
raytraceRenderer.ResetTracer();
transformationRenderer.ResetRenderer();
Glut.glutPostRedisplay();
}
else if (key == (byte)'c')
{
raytraceRenderer.renderingParameters.EnableAntialias = !raytraceRenderer.renderingParameters.EnableAntialias;
raytraceRenderer.ResetTracer();
transformationRenderer.ResetRenderer();
Glut.glutPostRedisplay();
}
else if (key == (byte)'v')
{
rendParams.EnableAntialias = !rendParams.EnableAntialias;
if (rendParams.EnableAntialias) Console.WriteLine("Antialising enabled");
else Console.WriteLine("Antialiasing disabled");
raytraceRenderer.ResetTracer();
transformationRenderer.ResetRenderer();
Glut.glutPostRedisplay();
}
}
public void UseDrawMeshRenderer()
{
rendererType = RendererType.DrawMeshRenderer;
}
public void UseUIVertexRenderer()
{
rendererType = RendererType.UIVertexRenderer;
}
