public static int GetShaderiv(int shader, ShaderParameter pname)
{
int result = 0;
glGetShaderiv(shader, pname, ref result);
return(result);
}
public int this[ShaderParameter param] {
get {
int value;
GL.GetShader(mId, param, out value);
return(value);
}
}
public override void Load()
{
color_shader = Content.Get <ShaderProgram>("color_shader");
scanlines_shader = Content.Get <ShaderProgram>("scanlines");
current_shader = color_shader;
colors_shader_tint_color = color_shader.GetParameter("tint_color");
colors_shader_tint_color.SetValue(Color.White);
scanlines_shader_params = scanlines_shader.GetParameter("params");
scanlines_params = new Vector4(
1.0f, // Amount
0.5f, // Intensity
0.0f, // Time
0.0f
);
scanlines_shader_params.SetValue(scanlines_params);
sprite = new Sprite(Content.Get <Texture2D>("cat"));
sprite.SetOrigin(0.5f, 0.5f);
sprite2 = new Sprite(Content.Get <Texture2D>("seiken"));
sprite.SetOrigin(0.5f, 0.5f);
timer = new Timer();
timer.Every(20, UpdateColor);
}
/// <summary>
/// Creates a new material parameter GUI.
/// </summary>
/// <param name="shaderParam">Shader parameter to create the GUI for. Must be of texture type.</param>
/// <param name="material">Material the parameter is a part of.</param>
/// <param name="layout">Layout to append the GUI elements to.</param>
internal MaterialParamTextureGUI(ShaderParameter shaderParam, Material material, GUILayout layout)
: base(shaderParam)
{
LocString title = new LocEdString(shaderParam.name);
guiElem = new GUITextureField(title);
switch (shaderParam.type)
{
case ShaderParameterType.Texture2D:
case ShaderParameterType.Texture3D:
case ShaderParameterType.TextureCube:
guiElem.OnChanged += (x) =>
{
Resource resource = x.Value;
if (resource is Texture tex)
{
material.SetTexture(shaderParam.name, tex);
}
else if (resource is SpriteTexture spriteTex)
{
material.SetSpriteTexture(shaderParam.name, spriteTex);
}
EditorApplication.SetDirty(material);
};
break;
}
layout.AddElement(guiElem);
}
public unsafe static void GetShaderInfo(int shaderId, ShaderParameter name, out int result)
{
fixed(int *ptr = &result)
{
GetShaderiv(shaderId, (int)name, ptr);
}
}
public void DrawTransparent(Camera camera)
{
int gameWidgetIndex = camera.GameWidget.GameWidgetIndex;
Vector3 viewPosition = camera.ViewPosition;
Vector3 v = new Vector3(MathUtils.Floor(viewPosition.X), 0f, MathUtils.Floor(viewPosition.Z));
Matrix value = Matrix.CreateTranslation(v - viewPosition) * camera.ViewMatrix.OrientationMatrix * camera.ProjectionMatrix;
Display.BlendState = BlendState.AlphaBlend;
Display.DepthStencilState = DepthStencilState.Default;
Display.RasterizerState = ((m_subsystemSky.ViewUnderWaterDepth > 0f) ? RasterizerState.CullClockwiseScissor : RasterizerState.CullCounterClockwiseScissor);
m_transparentShader.GetParameter("u_origin").SetValue(v.XZ);
m_transparentShader.GetParameter("u_viewProjectionMatrix").SetValue(value);
m_transparentShader.GetParameter("u_viewPosition").SetValue(viewPosition);
m_transparentShader.GetParameter("u_texture").SetValue(m_subsystemAnimatedTextures.AnimatedBlocksTexture);
m_transparentShader.GetParameter("u_samplerState").SetValue(SettingsManager.TerrainMipmapsEnabled ? m_samplerStateMips : m_samplerState);
m_transparentShader.GetParameter("u_fogYMultiplier").SetValue(m_subsystemSky.VisibilityRangeYMultiplier);
m_transparentShader.GetParameter("u_fogColor").SetValue(new Vector3(m_subsystemSky.ViewFogColor));
ShaderParameter parameter = m_transparentShader.GetParameter("u_fogStartInvLength");
for (int i = 0; i < m_chunksToDraw.Count; i++)
{
TerrainChunk terrainChunk = m_chunksToDraw[i];
float num = MathUtils.Min(terrainChunk.FogEnds[gameWidgetIndex], m_subsystemSky.ViewFogRange.Y);
float num2 = MathUtils.Min(m_subsystemSky.ViewFogRange.X, num - 1f);
parameter.SetValue(new Vector2(num2, 1f / (num - num2)));
int subsetsMask = 64;
DrawTerrainChunkGeometrySubsets(m_transparentShader, terrainChunk.Geometry, subsetsMask);
}
}
public static int GetShaderiv(int shader, ShaderParameter pname)
{
var ret = ES20.GL.GetShaderiv(shader, pname);
CheckError();
return(ret);
}
public static int GetShaderiv(uint shader, ShaderParameter parameter)
{
IntPtr result = IntPtr.Zero;
getShaderiv(shader, parameter, ref result);
return(result.ToInt32());
}
internal ShaderElementCollection(Shader shader, ShaderParameter parameter)
{
int count = parameter.ElementCount;
_parameters = new ShaderParameter[count];
for (int i = 0; i < count; i++)
_parameters[i] = new ShaderParameter(shader, shader.Effect.GetParameterElement(parameter.Handle, i));
}
internal ShaderParameterCollection(Shader shader)
{
int count = shader.Effect.Description.Parameters;
_parameters = new ShaderParameter[count];
for (int i = 0; i < count; i++)
_parameters[i] = new ShaderParameter(shader, shader.Effect.GetParameter(null, i));
}
public static void GetShader(uint shader, ShaderParameter param, out int value)
{
unsafe
{
fixed(int *a = &value)
{
Imports.glGetShaderiv(shader, (int)param, a);
}
}
}
internal ShaderParameterCollection(Shader shader)
{
int count = shader.Effect.Description.Parameters;
_parameters = new ShaderParameter[count];
for (int i = 0; i < count; i++)
{
_parameters[i] = new ShaderParameter(shader, shader.Effect.GetParameter(null, i));
}
}
internal ShaderElementCollection(Shader shader, ShaderParameter parameter)
{
int count = parameter.ElementCount;
_parameters = new ShaderParameter[count];
for (int i = 0; i < count; i++)
{
_parameters[i] = new ShaderParameter(shader, shader.Effect.GetParameterElement(parameter.Handle, i));
}
}
static void CheckShaderError(int shader, ShaderParameter shaderParam, string errorMessage)
{
int success;
GL.GetShader(shader, shaderParam, out success);
if (success == 0)
{
string error = GL.GetShaderInfoLog(shader);
Console.WriteLine(errorMessage + ": '" + error + "'");
}
}
public int this[ShaderParameter parameter]
{
get
{
if (!parameter.IsDefined())
{
throw new ArgumentOutOfRangeException("parameter", parameter, "The specified shader parameter was not a defined OpenTK.Graphics.OpenGL.ShaderParameter value.");
}
int value;
GL.GetShader(ID, parameter, out value);
return(value);
}
}
/// <summary>
/// Creates a new material parameter GUI.
/// </summary>
/// <param name="shaderParam">Shader parameter to create the GUI for. Must be of color type.</param>
/// <param name="material">Material the parameter is a part of.</param>
/// <param name="layout">Layout to append the GUI elements to.</param>
internal MaterialParamColorGUI(ShaderParameter shaderParam, Material material, GUILayout layout)
: base(shaderParam)
{
LocString title = new LocEdString(shaderParam.name);
guiElem = new GUIColorField(title);
guiElem.OnChanged += (x) =>
{
material.SetColor(shaderParam.name, x);
EditorApplication.SetDirty(material);
};
layout.AddElement(guiElem);
}
public int this[ShaderParameter parameter]
{
get
{
if (!parameter.IsDefined())
{
throw new ArgumentOutOfRangeException("parameter", parameter, "The specified shader parameter was not a defined OpenTK.Graphics.OpenGL.ShaderParameter value.");
}
int value;
GL.GetShader(ID, parameter, out value);
return value;
}
}
public override void SetShaderParameters(Device device, DeviceContext deviceContext, MaterialParameters matParams)
{
base.SetShaderParameters(device, deviceContext, matParams);
Shader_50760736Params parameters = new Shader_50760736Params();
var material = matParams.MaterialData;
if (material.Parameters.ContainsKey("C005"))
{
ShaderParameter param = material.Parameters["C005"];
parameters.C005_EmissiveFacadeColorAndIntensity = new Vector4(param.Paramaters[0], param.Paramaters[1], param.Paramaters[2], param.Paramaters[3]);
}
else
{
parameters.C005_EmissiveFacadeColorAndIntensity = new Vector4(0f);
}
if (material == null)
{
ShaderResourceView texture = RenderStorageSingleton.Instance.TextureCache[0];
deviceContext.PixelShader.SetShaderResource(0, texture);
ShaderParams = parameters;
}
else
{
ShaderParameterSampler sampler;
ShaderResourceView[] textures = new ShaderResourceView[2];
if (material.Samplers.TryGetValue("S000", out sampler))
{
textures[0] = RenderStorageSingleton.Instance.TextureCache[sampler.TextureHash];
}
else
{
textures[0] = RenderStorageSingleton.Instance.TextureCache[0];
}
if (material.Samplers.TryGetValue("S011", out sampler))
{
textures[1] = RenderStorageSingleton.Instance.TextureCache[sampler.TextureHash];
}
else
{
textures[1] = RenderStorageSingleton.Instance.TextureCache[0];
}
deviceContext.PixelShader.SetShaderResources(0, textures.Length, textures);
}
ShaderParams = parameters;
}
/// <summary>
/// Creates a new material parameter GUI.
/// </summary>
/// <param name="shaderParam">Shader parameter to create the GUI for. Must be of texture type.</param>
/// <param name="material">Material the parameter is a part of.</param>
/// <param name="layout">Layout to append the GUI elements to.</param>
internal MaterialParamTextureGUI(ShaderParameter shaderParam, Material material, GUILayout layout)
: base(shaderParam)
{
LocString title = new LocEdString(shaderParam.name);
GUITextureFieldType type = shaderParam.type == ShaderParameterType.Texture2D ?
GUITextureFieldType.TextureOrSpriteTexture :
GUITextureFieldType.Texture;
guiElem = new GUITextureField(type, title);
switch (shaderParam.type)
{
case ShaderParameterType.Texture2D:
case ShaderParameterType.Texture3D:
case ShaderParameterType.TextureCube:
guiElem.OnChanged += (x) =>
{
string path = ProjectLibrary.GetPath(x.UUID);
if (!string.IsNullOrEmpty(path))
{
if (ProjectLibrary.GetEntry(path) is FileEntry fileEntry)
{
if (fileEntry.ResourceMetas.Length > 0)
{
ResourceMeta meta = fileEntry.ResourceMetas[0];
if (meta.ResType == ResourceType.SpriteTexture)
{
material.SetSpriteTexture(shaderParam.name, x.As <SpriteTexture>());
}
else if (meta.ResType == ResourceType.Texture)
{
material.SetTexture(shaderParam.name, x.As <Texture>());
}
}
}
}
else
{
material.SetTexture(shaderParam.name, null);
}
EditorApplication.SetDirty(material);
};
break;
}
layout.AddElement(guiElem);
}
/// <summary>
/// Creates a new material parameter GUI.
/// </summary>
/// <param name="shaderParam">Shader parameter to create the GUI for. Must be of color type.</param>
/// <param name="material">Material the parameter is a part of.</param>
/// <param name="layout">Layout to append the GUI elements to.</param>
internal MaterialParamColorGUI(ShaderParameter shaderParam, Material material, GUILayout layout)
: base(shaderParam)
{
LocString title = new LocEdString(shaderParam.name);
var guiToggle = new GUIToggle(new GUIContent(
EditorBuiltin.GetEditorToggleIcon(EditorToggleIcon.AnimateProperty), new LocString("Animate")));
guiColor = new GUIColorField(title);
guiColorGradient = new GUIColorGradientField(title);
bool isAnimated = material.IsAnimated(shaderParam.name);
guiColor.Active = !isAnimated;
guiColorGradient.Active = isAnimated;
fieldLayout = layout.AddLayoutX();
fieldLayout.AddElement(guiColor);
fieldLayout.AddElement(guiColorGradient);
fieldLayout.AddSpace(10);
fieldLayout.AddElement(guiToggle);
guiColor.OnChanged += (x) =>
{
material.SetColor(shaderParam.name, x);
EditorApplication.SetDirty(material);
};
guiColorGradient.OnChanged += x =>
{
material.SetColorGradient(shaderParam.name, x);
EditorApplication.SetDirty(material);
};
guiToggle.OnToggled += x =>
{
guiColor.Active = !x;
guiColorGradient.Active = x;
if (x)
{
ColorGradient gradient = material.GetColorGradient(shaderParam.name);
if (gradient.NumKeys == 0)
{
material.SetColorGradient(shaderParam.name, new ColorGradient(material.GetColor(shaderParam.name)));
}
}
};
}
public override void SetShaderParamters(Device device, DeviceContext deviceContext, Material material)
{
Shader_601151254Params parameters = new Shader_601151254Params();
if (material.Parameters.ContainsKey("C002"))
{
ShaderParameter param = material.Parameters["C002"];
parameters.C002_MaterialColor = new Vector4(param.Paramaters[0], param.Paramaters[1], param.Paramaters[2], param.Paramaters[3]);
}
else
{
parameters.C002_MaterialColor = new Vector4(0f);
}
ShaderParams = parameters;
}
public static PixelShaderBlock GeneratePixelShaderBlock(HaloOnlineCacheContext cacheContext, ShaderGeneratorResult shader_gen_result)
{
var pixelShaderBlock = new PixelShaderBlock
{
PCShaderBytecode = shader_gen_result.Bytecode,
PCParameters = new List <ShaderParameter>()
};
foreach (var register in shader_gen_result.Registers)
{
ShaderParameter shaderParameter = new ShaderParameter
{
RegisterIndex = (ushort)register.Register,
RegisterCount = (byte)register.Size
};
switch (register.registerType)
{
case HaloShaderGenerator.ShaderGeneratorResult.ShaderRegister.RegisterType.Boolean:
shaderParameter.RegisterType = ShaderParameter.RType.Boolean;
break;
case HaloShaderGenerator.ShaderGeneratorResult.ShaderRegister.RegisterType.Integer:
shaderParameter.RegisterType = ShaderParameter.RType.Integer;
break;
case HaloShaderGenerator.ShaderGeneratorResult.ShaderRegister.RegisterType.Sampler:
shaderParameter.RegisterType = ShaderParameter.RType.Sampler;
break;
case HaloShaderGenerator.ShaderGeneratorResult.ShaderRegister.RegisterType.Vector:
shaderParameter.RegisterType = ShaderParameter.RType.Vector;
break;
default:
throw new NotImplementedException();
}
shaderParameter.ParameterName = cacheContext.GetStringId(register.Name);
pixelShaderBlock.PCParameters.Add(shaderParameter);
}
return(pixelShaderBlock);
}
/// <summary>
/// Creates a new material parameter GUI.
/// </summary>
/// <param name="shaderParam">Shader parameter to create the GUI for. Must be of 4x4 matrix type.</param>
/// <param name="material">Material the parameter is a part of.</param>
/// <param name="layout">Layout to append the GUI elements to.</param>
internal MaterialParamMat4GUI(ShaderParameter shaderParam, Material material, GUILayout layout)
: base(shaderParam)
{
LocString title = new LocEdString(shaderParam.name);
GUILabel guiTitle = new GUILabel(title, GUIOption.FixedWidth(100));
mainLayout = layout.AddLayoutY();
GUILayoutX titleLayout = mainLayout.AddLayoutX();
titleLayout.AddElement(guiTitle);
titleLayout.AddFlexibleSpace();
GUILayoutY contentLayout = mainLayout.AddLayoutY();
GUILayoutX[] rows = new GUILayoutX[MAT_SIZE];
for (int i = 0; i < rows.Length; i++)
{
rows[i] = contentLayout.AddLayoutX();
}
for (int row = 0; row < MAT_SIZE; row++)
{
for (int col = 0; col < MAT_SIZE; col++)
{
int index = row * MAT_SIZE + col;
guiMatFields[index] = new GUIFloatField(row + "," + col, 20, "", GUIOption.FixedWidth(80));
GUIFloatField field = guiMatFields[index];
rows[row].AddElement(field);
rows[row].AddSpace(5);
int hoistedRow = row;
int hoistedCol = col;
field.OnChanged += (x) =>
{
Matrix4 value = material.GetMatrix4(shaderParam.name);
value[hoistedRow, hoistedCol] = x;
material.SetMatrix4(shaderParam.name, value);
EditorApplication.SetDirty(material);
};
}
}
}
public RenderPrefabs()
{
GizmoRed = new Material();
GizmoBlue = new Material();
GizmoGreen = new Material();
GizmoRed.MaterialName = "GizmoRed";
GizmoRed.MaterialHash = 1337;
GizmoBlue.MaterialName = "GizmoBlue";
GizmoBlue.MaterialHash = 1338;
GizmoGreen.MaterialName = "GizmoGreen";
GizmoGreen.MaterialHash = 1339;
GizmoRed.UFO1 = GizmoBlue.UFO1 = GizmoGreen.UFO1 = 128;
GizmoRed.ShaderID = GizmoBlue.ShaderID = GizmoGreen.ShaderID = 3854590933660942049;
GizmoRed.ShaderHash = GizmoBlue.ShaderHash = GizmoGreen.ShaderHash = 601151254;
GizmoRed.Parameters = new Dictionary <string, ShaderParameter>();
ShaderParameter param = new ShaderParameter();
param.ID = "C002";
param.Paramaters = new float[4] {
1.0f, 0.0f, 0.0f, 1.0f
};
GizmoRed.Parameters.Add("C002", param);
GizmoBlue.Parameters = new Dictionary <string, ShaderParameter>();
param = new ShaderParameter();
param.ID = "C002";
param.Paramaters = new float[4] {
0.0f, 1.0f, 0.0f, 1.0f
};
GizmoBlue.Parameters.Add("C002", param);
GizmoGreen.Parameters = new Dictionary <string, ShaderParameter>();
param = new ShaderParameter();
param.ID = "C002";
param.Paramaters = new float[4] {
0.0f, 0.0f, 1.0f, 1.0f
};
GizmoGreen.Parameters.Add("C002", param);
}
/// <summary>
/// Creates a new material parameter GUI.
/// </summary>
/// <param name="shaderParam">Shader parameter to create the GUI for. Must be of texture type.</param>
/// <param name="material">Material the parameter is a part of.</param>
/// <param name="layout">Layout to append the GUI elements to.</param>
internal MaterialParamTextureGUI(ShaderParameter shaderParam, Material material, GUILayout layout)
: base(shaderParam)
{
LocString title = new LocEdString(shaderParam.Name);
guiElem = new GUITextureField(title);
switch (shaderParam.Type)
{
case ShaderParameterType.Texture2D:
guiElem.OnChanged += (x) =>
{
Texture2D texture = Resources.Load <Texture2D>(x);
material.SetTexture2D(shaderParam.Name, texture);
EditorApplication.SetDirty(material);
};
break;
case ShaderParameterType.Texture3D:
guiElem.OnChanged += (x) =>
{
Texture3D texture = Resources.Load <Texture3D>(x);
material.SetTexture3D(shaderParam.Name, texture);
EditorApplication.SetDirty(material);
};
break;
case ShaderParameterType.TextureCube:
guiElem.OnChanged += (x) =>
{
TextureCube texture = Resources.Load <TextureCube>(x);
material.SetTextureCube(shaderParam.Name, texture);
EditorApplication.SetDirty(material);
};
break;
}
layout.AddElement(guiElem);
}
public void Read(Stream r)
{
HashPart1 = r.ReadValueU32();
HashPart2 = r.ReadValueU32();
HashComplete = ((ulong)HashPart2 << 32 | (ulong)HashPart1);
int length = r.ReadValueS32();
byte[] bytes = r.ReadBytes(length);
Name = Encoding.ASCII.GetString(bytes);
alpha1 = r.ReadValueU8();
alpha2 = r.ReadValueU8();
unk3 = r.ReadValueS32();
unk4 = r.ReadValueU8();
this.unk5 = r.ReadValueS32();
unk6 = r.ReadValueS32();
UnkHash = r.ReadValueS32(); // mafia 3
ShaderHash = r.ReadValueU64();
AdaptHash = r.ReadValueU32();
int count = r.ReadValueS32();
Parameters = new ShaderParameter[count];
for (int i = 0; i < count; i++)
{
Parameters[i] = new ShaderParameter(r);
}
count = r.ReadValueS32();
Samplers = new ShaderParameterSampler[count];
for (int j = 0; j < count; j++)
{
Samplers[j] = new ShaderParameterSampler(r);
}
count = r.ReadValueS32();
for (int j = 0; j < count; j++)
{
var fourcc = Encoding.ASCII.GetString(r.ReadBytes(4));
var unk5 = r.ReadBytes(12);
}
}
public ModelShader(bool useAlphaThreshold, int maxInstancesCount = 1)
: base(ContentManager.Get <string>("Shaders/ModelVsh"), ContentManager.Get <string>("Shaders/ModelPsh"), PrepareShaderMacros(useAlphaThreshold, maxInstancesCount))
{
m_worldMatrixParameter = GetParameter("u_worldMatrix");
m_worldViewProjectionMatrixParameter = GetParameter("u_worldViewProjectionMatrix");
m_textureParameter = GetParameter("u_texture");
m_samplerStateParameter = GetParameter("u_samplerState");
m_materialColorParameter = GetParameter("u_materialColor");
m_emissionColorParameter = GetParameter("u_emissionColor");
m_alphaThresholdParameter = GetParameter("u_alphaThreshold", allowNull: true);
m_ambientLightColorParameter = GetParameter("u_ambientLightColor");
m_diffuseLightColor1Parameter = GetParameter("u_diffuseLightColor1");
m_directionToLight1Parameter = GetParameter("u_directionToLight1");
m_diffuseLightColor2Parameter = GetParameter("u_diffuseLightColor2");
m_directionToLight2Parameter = GetParameter("u_directionToLight2");
m_fogColorParameter = GetParameter("u_fogColor");
m_fogStartInvLengthParameter = GetParameter("u_fogStartInvLength");
m_fogYMultiplierParameter = GetParameter("u_fogYMultiplier");
m_worldUpParameter = GetParameter("u_worldUp");
Transforms = new ShaderTransforms(maxInstancesCount);
}
private void AddShaderParam(List <ShaderParamNames> paramNames, List <ShaderParameter> paramValues, ShaderParamNames paramName, object paramValue)
{
var p = new ShaderParameter();
p.Data = paramValue;
if (paramValue is TextureBase)
{
p.DataType = 0;
p.Unknown_1h = (byte)((paramNames.Count > 0) ? paramNames.Count + 1 : 0);//seriously wtf is this?
}
else if (paramValue is Vector4)
{
p.DataType = 1;
}
else
{
}
paramNames.Add(paramName);
paramValues.Add(p);
}
/// <summary>
/// Creates a new material parameter GUI.
/// </summary>
/// <param name="shaderParam">Shader parameter to create the GUI for. Must be of floating point type.</param>
/// <param name="material">Material the parameter is a part of.</param>
/// <param name="layout">Layout to append the GUI elements to.</param>
internal MaterialParamFloatGUI(ShaderParameter shaderParam, Material material, GUILayout layout)
: base(shaderParam)
{
LocString title = new LocEdString(shaderParam.name);
var guiToggle = new GUIToggle(new GUIContent(
EditorBuiltin.GetEditorToggleIcon(EditorToggleIcon.AnimateProperty), new LocString("Animate")));
guiConstant = new GUIFloatField(title);
guiCurves = new GUICurvesField(title);
bool isAnimated = material.IsAnimated(shaderParam.name);
guiConstant.Active = !isAnimated;
guiCurves.Active = isAnimated;
fieldLayout = layout.AddLayoutX();
fieldLayout.AddElement(guiConstant);
fieldLayout.AddElement(guiCurves);
fieldLayout.AddSpace(10);
fieldLayout.AddElement(guiToggle);
guiConstant.OnChanged += (x) =>
{
material.SetFloat(shaderParam.name, x);
EditorApplication.SetDirty(material);
};
guiCurves.OnChanged += x =>
{
material.SetFloatCurve(shaderParam.name, x);
EditorApplication.SetDirty(material);
};
guiToggle.OnToggled += x =>
{
guiConstant.Active = !x;
guiCurves.Active = x;
};
}
public static void GetShader(int shader, ShaderParameter pname, out int parm)
{
ES20.GL.GetShader(shader, pname, out parm);
CheckError();
}
internal int GetInt(ShaderParameter pname)
{
int result; using (Context.Lock()) GL.GetShader(Id, pname, out result); return result;
}
/// <summary>
/// Creates a new material parameter GUI.
/// </summary>
/// <param name="shaderParam">Shader parameter to create the GUI for.</param>
protected MaterialParamGUI(ShaderParameter shaderParam)
{
this.shaderParam = shaderParam;
}
public static void GetShader(uint shader, ShaderParameter shaderParameter, out int parameter)
{
InvokeExtensionFunction <glGetShaderiv>()(shader, (uint)shaderParameter, out parameter);
}
public bool GetShaderStatus(int handle, ShaderParameter pname)
{
GraphicsContext.Assert();
int @params;
GL.GetShader(handle, pname, out @params);
OpenGlErrorHelper.CheckGlError();
return @params == 0 ? false : true;
}
public static int GetShader(uint shader, ShaderParameter pname)
{
sint1[0] = 0;
GetShaderiv(shader, pname, sint1);
return(sint1[0]);
}
public extern object GetShaderParameter(WebGLShader shader, ShaderParameter pname);
