4. Cg 3 vs. D3D11 HLSL

Cg 3 vs. D3D11 HLSL

  • V

    ich meine mich noch daran erinnern zu können, das früher der einzige Unterschied zwischen Cg und HLSL einfach nur der Name war. Beide waren gleich zu benutzen. Wie sieht das heute mit Cg 3 aus in Bezug auf mit Hull und Domain Shader? Ich habe mir im Cg 3.0 Toolkit die Beispiele angesehen, aber die Syntax der Shader war wirklich hässlich und hat nichts mehr mit HLSL zu tun - habe ich da etwas verwechselt/falsch verstanden oder sind da Cg und HLSL letztendlich getrennte Wege gegangen?

    0
  • H

    CG war schon immer eine eigenstaendige Sprache.
    Es bietet jedoch die Moeglichkeit sowohl GLSL- als auch HLSL-Code aus dem CG-Source zu erzeugen.

    0
  • V

    was ich meinte war:

    "NVIDIA and Microsoft collaborated to develop the Cg language. Microsoft calls its implementation High-Level Shading Language, or HLSL for short. HLSL and Cg are the same language but reflect the different names each company uses to identify the language and its underlying technology."

    zu lesen hier http://http.developer.nvidia.com/CgTutorial/cg_tutorial_chapter01.html oder im Buch "The Cg Tutorial"

    Ich habe damit verstanden, das es zwischen Cg und HLSL keinen unterschied gibt - ich hab mir jetzt mal D3D11 Shader angesehen ohne DXUT Effekt Framework (sind das HLSL11 Shader?) und die Shader die im Cg Toolkit 3 waren - beides waren Tesselierungsshader was bedeutet, dass diese doch relativ aktuell waren - und ich wollte wissen ob die Sprachen wie ich offensichtlich festgestellt habe jetzt doch getrennte Wegge gegangen sind - oder ob das nur das häsliche Cg Effekt Framework ist

    0

  • Nun, afaik waren HLSL und Cg auch defacto nur zwei Implementierungen der selben Sprache. Natürlich kann es sein dass NVIDIA letztendlich doch getrennte Wege geht, was mich aber irgendwie wundern würde. Ich hab grad kein Cg Toolkit zur Hand, vielleicht kannst du den Code von dem du sprichst mal auszugsweise posten?

    0
  • V

    aus dem Cg 3 Toolkit (NVIDIA Cg 3.0 July 2010):

    Cg\examples\Direct3D11\basic\cgfx_buffer.cgfx:

    struct VOutput 
{
  float4 position : POSITION;
  float3 color    : COLOR;
};

struct Buffer0
{
    float4 VertexColor;
} CBuffer0 : BUFFER[0];

VOutput vs( float2 position : POSITION )
{	
  VOutput OUT;

  OUT.position = float4( position, 0, 1 );
  OUT.color = CBuffer0.VertexColor.xyz;

  return OUT;
}

struct POutput
{
  float4 color : COLOR;
};

POutput ps( VOutput input )
{
  POutput OUT;
  OUT.color = float4( input.color, 1.0 );
  return OUT;
}

technique cgfx_buffer
{
  pass
  {
      AlphaBlendEnable = false;
      CullMode = None;
      FillMode = Solid;

      VertexProgram = compile vs_5_0 vs();
      FragmentProgram = compile ps_5_0 ps();
  }
}

    das oben sieht aus wie normales HLSL mit DXUT Effektframework - da sehe ich keinen Unterschied

    aber hier Cg\examples\OpenGL\advanced\cgfx_tessellation :

    // The shader writes a uniform parameter to the inner and edge tessellation factors.

gp5tcp PATCH_16
void main
(
  in int ndx                      : CONTROLPOINT_ID,
  in AttribArray<float3> position : POSITION,
  in AttribArray<float2> texCoord : TEXCOORD0,

  out float4 oPosition     : POSITION,
  out float2 oTexCoord     : TEXCOORD0,
  out float  oEdgeTess[4]  : EDGETESS,
  out float  oInnerTess[2] : INNERTESS,

  uniform float2   innerTess,
  uniform float4   outerTess,

  uniform float4x4 modelView
)
{
  oPosition = float4(position[ndx], 1);
  oPosition = mul(modelView,oPosition);
  oTexCoord = texCoord[ndx];

  oEdgeTess[0] = outerTess.x;
  oEdgeTess[1] = outerTess.y;
  oEdgeTess[2] = outerTess.z;
  oEdgeTess[3] = outerTess.w;

  oInnerTess[0] = innerTess.x;
  oInnerTess[1] = innerTess.y;
}

gp5tep PATCH_16 QUADS ORDER_CCW
void main
(
  in float2 uv                    : UV,
  in AttribArray<float3> position : POSITION,
  in AttribArray<float2> texcoord : TEXCOORD0,

  out float4 oPosition : POSITION,
  out float3 oNormal   : TEXCOORD1,
  out float2 oUV       : TEXCOORD2,
  out float3 oGradU    : TEXCOORD3,
  out float3 oGradV    : TEXCOORD4,
  out float4 oTexCoord : TEXCOORD5,

  uniform float4x4 projection
)
{
  // Compute Bernstein weights for U (1 ADD, 8 MULs)
  float  u          = uv.x;
  float  uu         = u*u;
  float  oneMinusU  = 1-u;
  float  oneMinusUU = oneMinusU*oneMinusU;
  float3 Bu[4] =
//...

    Tesselierungsshader in D3D11 - mit HLSL ohne Effektframework:

    HS_CONSTANT_OUTPUT HSConstant( InputPatch<VS_OUTPUT, 4> ip, uint pid : SV_PrimitiveID )
{
	HS_CONSTANT_OUTPUT output;

	float edge = 1;//32.0f;
	float inside = 1;//32.0f;

	output.edges[0] = 4;//edge;
	output.edges[1] = edge;
	output.edges[2] = edge;
	output.edges[3] = edge;

	output.inside[0] = inside;
	output.inside[1] = inside;

	return output;
}

[domain("quad")]
[partitioning("integer")]
[outputtopology("triangle_cw")]
[outputcontrolpoints(4)]
[patchconstantfunc("HSConstant")]
HS_OUTPUT HS_Quad( InputPatch<VS_OUTPUT, 4> ip, uint cpid : SV_OutputControlPointID, uint pid : SV_PrimitiveID )
{
	HS_OUTPUT Output;
    Output.position = ip[cpid].position;
    return Output;
}

[domain("quad")]
DS_OUTPUT DS_Quad( HS_CONSTANT_OUTPUT input, float2 UV : SV_DomainLocation, const OutputPatch<HS_OUTPUT, 4> patch )
{
    DS_OUTPUT Output;

    float3 topMidpoint = lerp(patch[0].position, patch[1].position, UV.x);
    float3 bottomMidpoint = lerp(patch[3].position, patch[2].position, UV.x);

    Output.color = float4(UV.yx, 1-UV.x, 1);

	Output.position = float4(lerp(topMidpoint, bottomMidpoint, UV.y), 1);
	Output.position = mul( float4(lerp(topMidpoint, bottomMidpoint, UV.y), 1), g_mViewProjection);

    return Output;    
}

    Unterschiede
    Es gibt keine Annotationen:

    [domain("quad")]
[partitioning("integer")]
[outputtopology("triangle_cw")]
[outputcontrolpoints(4)]
[patchconstantfunc("HSConstant")]

    es gibt nicht das Schlüsselwort InputPatch usw.

    Es scheint nicht mehr so kompatibel zu sein wie es schon mal war...

    0

  • Ok das ist interessant. Bleibt die Frage offen ob HLSL und Cg nun tatsächlich zu divergieren beginnen oder ob es sich dabei einfach nur um eine alternative Syntax handelt die Cg erlaubt. Um ehrlich zu sein bin ich damit überfragt da ich mit Cg nie was zu tun hab, aber sieht mir irgendwie eher danach aus als würden HLSL und Cg nun tatsächlich getrennte Wege gehen...

    0
  • V

    Bleibt die Frage offen ob HLSL und Cg nun tatsächlich zu divergieren beginnen oder ob es sich dabei nur um eine alternative Syntax handelt die Cg erlaubt ist.

    Genau das sind die Fragen zu denen mich Antworten interessieren würden!

    Ich habe bisher mit Cg und in letzter Zeit mit D3D10 HLSL + Effektframework gearbeitet - ich kann halt damit Shader schreiben und hab auch schon einige Effekte damit programmiert, aber jedes Syntaxelement kenne ich da auch nicht 😉

    Nun fange ich gerade ein neues Projekt mit Tesselierung an mit dem Hitergedanken irgendwann vielleicht auch mal einfach das ganze auf OpenGL poritieren zu können - die unteschiede zwischen D3D11 HLSL ohne Effektframework und GLSL 4.1 sind schon groß:

    Hier etwas das man in D3D11 als Domain-Shader bezeichnen würde:

    #version 410 core

// Declare all the semantics
#define ATTR_POSITION	0
#define ATTR_COLOR		3
#define FRAG_COLOR		0

layout(quads, equal_spacing, ccw) in;

in vec4 ContColor[];
out vec4 EvalColor;

in gl_PerVertex
{
	vec4 gl_Position;
	float gl_PointSize;
	float gl_ClipDistance[];
} gl_in[];

out gl_PerVertex
{
	vec4 gl_Position;
	float gl_PointSize;
	float gl_ClipDistance[];
};

vec4 interpolate(in vec4 v0, in vec4 v1, in vec4 v2, in vec4 v3)
{
	vec4 a = mix(v0, v1, gl_TessCoord.x);
	vec4 b = mix(v3, v2, gl_TessCoord.x);
	return mix(a, b, gl_TessCoord.y);
}

void main()
{	
	gl_Position = interpolate(gl_in[0].gl_Position, gl_in[1].gl_Position, gl_in[2].gl_Position, gl_in[3].gl_Position);
	EvalColor = interpolate(ContColor[0], ContColor[1], ContColor[2], ContColor[3]);
}

    und da wollte ich jetzt Cg nutzen mit dem Hintergedanken das ganze portabel zu halten - habe aber leider festgestellt, dass es da anscheinend auch unterschiede gibt - hätte halt gerne so wie frührer mit HLSL programmiert und gerne Cg benutzt um auch OpenGL zu haben... mmmh....

    0
Anmelden zum Antworten