📄 shader.c
字号:
{
bValidInfo = pShaderAttribTable->validTableInfo;
if(bValidInfo)
{
nInAttribNum = pShaderAttribTable->inAttribTableSize;
nOutAttribNum = pShaderAttribTable->outAttribTableSize;
if((nInAttribNum > 0) && (nOutAttribNum > 0) && (nOutAttribNum > nInAttribNum))
{
pOutAttribTable = (unsigned int *)&pShaderAttribTable->vsOutAttribTable[0];
pInAttribTable = (unsigned int *)&pShaderAttribTable->psInAttribTable[0];
uAttribIndex = _SearchAttribTable(pOutAttribTable, nOutAttribNum, FGL_ATRBDEF_POINTSIZE);
if(uAttribIndex != FGL_ZERO)
{
uIndexCount++;
FGL_SET_BITFIELD(OutAttribIndex0, 11:8, uIndexCount);
}
for(i = 0; i < nInAttribNum; i++)
{
uAttribIndex = _SearchAttribTable(pOutAttribTable, nOutAttribNum, (FGL_DeclareAttrib)pInAttribTable[i]);
if(uAttribIndex != FGL_ZERO)
{
uIndexCount++;
switch(uIndexCount)
{
case FGSP_ATTRIBUTE_INDEX1:
FGL_SET_BITFIELD(OutAttribIndex0, 11:8, uAttribIndex);
break;
case FGSP_ATTRIBUTE_INDEX2:
FGL_SET_BITFIELD(OutAttribIndex0, 19:16, uAttribIndex);
break;
case FGSP_ATTRIBUTE_INDEX3:
FGL_SET_BITFIELD(OutAttribIndex0, 27:24, uAttribIndex);
break;
case FGSP_ATTRIBUTE_INDEX4:
FGL_SET_BITFIELD(OutAttribIndex1, 3:0, uAttribIndex);
break;
case FGSP_ATTRIBUTE_INDEX5:
FGL_SET_BITFIELD(OutAttribIndex1, 11:8, uAttribIndex);
break;
case FGSP_ATTRIBUTE_INDEX6:
FGL_SET_BITFIELD(OutAttribIndex1, 19:16, uAttribIndex);
break;
case FGSP_ATTRIBUTE_INDEX7:
FGL_SET_BITFIELD(OutAttribIndex1, 27:24, uAttribIndex);
break;
case FGSP_ATTRIBUTE_INDEX8:
FGL_SET_BITFIELD(OutAttribIndex2, 3:0, uAttribIndex);
break;
case FGSP_ATTRIBUTE_INDEX9:
FGL_SET_BITFIELD(OutAttribIndex2, 11:8, uAttribIndex);
break;
case FGSP_ATTRIBUTE_INDEXA:
FGL_SET_BITFIELD(OutAttribIndex2, 19:16, uAttribIndex);
break;
case FGSP_ATTRIBUTE_INDEXB:
FGL_SET_BITFIELD(OutAttribIndex2, 27:24, uAttribIndex);
break;
default:
break;
}
}
else
{
//printf();
return FGL_ERR_INVALID_VALUE;
}
}
WRITEREG(FGVS_OUT_ATTRIB_IDX0, OutAttribIndex0);
WRITEREG(FGVS_OUT_ATTRIB_IDX1, OutAttribIndex1);
WRITEREG(FGVS_OUT_ATTRIB_IDX2, OutAttribIndex2);
ret = FGL_ERR_NO_ERROR;
}
else
{
//printf();
ret = FGL_ERR_INVALID_VALUE;
}
}
else
{
//printf();
ret = FGL_ERR_INVALID_VALUE;
}
}
else
{
//printf();
ret = FGL_ERR_INVALID_PARAMETER;
}
return ret;
}
/*****************************************************************************
* FUNCTIONS: fglSetVShaderAttribTable
* SYNOPSIS: This function specifies in/out arrributes order of the vertex
* shader program which vertex shader will be used.
* PARAMETERS: [in] idx - a index of the attribute table.
* [in] value - a value to order attributes.
* RETURNS: FGL_ERR_NO_ERROR, if successful
* FGL_ERR_INVALID_PARAMETER - the idx is not a type of enumeration.
* FGL_ERR_INVALID_VALUE - the PC exceeds the range of max attributes
* ERRNO: FGL_ERR_NO_ERROR 1
* FGL_ERR_INVALID_PARAMETER 2
* FGL_ERR_INVALID_VALUE 7
*****************************************************************************/
FGL_Error
fglSetVShaderAttribTable (
FGL_AttribTableIdx idx,
unsigned int value
)
{
int i = 0;
unsigned int uSubVal = 0;
FGL_BOOL bValidParam = FGL_TRUE;
for(i = 0; i < 4; i++)
{
uSubVal = (value >> (i*FGSP_ATTRIB_IO_IDX_SHIFT)) & FGSP_ATTRIB_IO_IDX_MASK;
if(uSubVal > FGSP_ATTRIBUTE_INDEXB && bValidParam)
bValidParam = FGL_FALSE;
}
if(bValidParam)
{
switch(idx)
{
case FGL_INPUT_ATTRIB_IDX0:
WRITEREG(FGVS_IN_ATTRIB_IDX0, value);
break;
case FGL_INPUT_ATTRIB_IDX1:
WRITEREG(FGVS_IN_ATTRIB_IDX1, value);
break;
case FGL_INPUT_ATTRIB_IDX2:
WRITEREG(FGVS_IN_ATTRIB_IDX2, value);
break;
case FGL_OUTPUT_ATTRIB_IDX0:
WRITEREG(FGVS_OUT_ATTRIB_IDX0, value);
break;
case FGL_OUTPUT_ATTRIB_IDX1:
WRITEREG(FGVS_OUT_ATTRIB_IDX1, value);
break;
case FGL_OUTPUT_ATTRIB_IDX2:
WRITEREG(FGVS_OUT_ATTRIB_IDX2, value);
break;
default:
return FGL_ERR_INVALID_PARAMETER;
}
return FGL_ERR_NO_ERROR;
}
else
{
return FGL_ERR_INVALID_VALUE;
}
}
// Fragment Shader Register-level API
/*****************************************************************************
* FUNCTIONS: fglPSSetPCRange
* SYNOPSIS: This function specifies the start and end address of the fragment
* shader program which fragment shader will be used.
* PARAMETERS: [in] start - a start address of the pixel shader program.
* [in] end - an end address of the pixel shader program.
* RETURNS: FGL_ERR_NO_ERROR, if successful
* FGL_ERR_INVALID_VALUE - the PC exceeds the range of 512 slots
* ERRNO: FGL_ERR_NO_ERROR 1
* FGL_ERR_INVALID_VALUE 7
*****************************************************************************/
FGL_Error
fglPSSetPCRange (unsigned int start, unsigned int end )
{
FGL_Error ret = FGL_ERR_UNKNOWN;
FGL_BOOL bValidPCStart = FGL_FALSE;
FGL_BOOL bValidPCEnd = FGL_FALSE;
bValidPCStart = PROGRAM_COUNT_VALUE_VALID(start);
bValidPCEnd = PROGRAM_COUNT_VALUE_VALID(end);
if(bValidPCStart && bValidPCEnd && (start <= end))
{
ret = _PSExecuteMode(FGL_HOST_ACCESS_MODE);
if (ret != FGL_ERR_NO_ERROR)
{
//printf((DBG_ERROR, " _PSExecuteMode is fail. - invalid Execute maode parameter"));
return ret;
}
WRITEREG(FGPS_PC_START, start); // Start address of pixel shader program
WRITEREG(FGPS_PC_END, end); // End address of pixel shader program
WRITEREG(FGPS_PC_COPY, PROGRAM_COUNT_COPYOUT);
ret = _PSExecuteMode(FGL_PS_EXECUTE_MODE);
if (ret != FGL_ERR_NO_ERROR)
{
//printf((DBG_ERROR, " _PSExecuteMode is fail. - invalid Execute maode parameter"));
return ret;
}
ret = FGL_ERR_NO_ERROR;
}
else
{
if(!bValidPCStart)
{
//printf((DBG_ERROR, "Cannot set pixel shader pc vlaue - invalid start pc value"));
}
if(!bValidPCEnd)
{
//printf((DBG_ERROR, "Cannot set pixel shader pc vlaue - invalid end pc value"));
}
ret = FGL_ERR_INVALID_VALUE;
}
return ret;
}
/*****************************************************************************
* FUNCTIONS: fglPSSetAttributeNum
* SYNOPSIS: this function specifies the value ranged between 1 and 8 according to
* the number of semantics such as color and texture coordinate
* which are transferred to pixel shader.
* PARAMETERS: [in] attributeNum - the number of attribute for current context.
* RETURNS: FGL_ERR_NO_ERROR, if successful
* FGL_ERR_INVALID_VALUE -the sizes of attribute exceed the maximum number.
* ERRNO: FGL_ERR_NO_ERROR 1
* FGL_ERR_INVALID_VALUE 7
*****************************************************************************/
FGL_Error
fglPSSetAttributeNum ( unsigned int attributeNum )
{
FGL_Error ret = FGL_ERR_UNKNOWN;
FGL_BOOL bValidNumAttrib = FGL_FALSE;
unsigned int uInBufStatus;
bValidNumAttrib = PS_MAX_ATTRIB_NUM_VALID(attributeNum);
if(bValidNumAttrib)
{
ret = _PSExecuteMode(FGL_HOST_ACCESS_MODE);
if (ret != FGL_ERR_NO_ERROR)
{
//printf((DBG_ERROR, " _PSExecuteMode is fail. - invalid Execute maode parameter"));
return ret;
}
WRITEREG(FGPS_ATTRIB_NUM, attributeNum);
do
{
fglPSGetInBufferStatus(&uInBufStatus);
}
while(INPUT_BUFFER_READY != uInBufStatus);
ret = _PSExecuteMode(FGL_PS_EXECUTE_MODE);
if (ret != FGL_ERR_NO_ERROR)
{
//printf((DBG_ERROR, " _PSExecuteMode is fail. - invalid Execute maode parameter"));
return ret;
}
ret = FGL_ERR_NO_ERROR;
}
else
{
//printf((DBG_ERROR, "Cannot set pixel shader pc vlaue - invalid end pc value"));
ret = FGL_ERR_INVALID_VALUE;
}
return ret;
}
/*****************************************************************************
* FUNCTIONS: fglPSGetInBufferStatus
* SYNOPSIS: this function read status register for monitoring fragment shader
* input buffer initialization status.
* PARAMETERS: [out] ready - the stauts signal which means that PS Input Buffer
* initialization is not completed.
* RETURNS: FGL_ERR_NO_ERROR, if successful
* ERRNO: FGL_ERR_NO_ERROR 1
*****************************************************************************/
FGL_Error
fglPSGetInBufferStatus ( unsigned int *ready )
{
FGL_Error ret = FGL_ERR_UNKNOWN;
unsigned int uInBufStatus = 0;
READREGP(FGPS_INBUF_STATUS, uInBufStatus);
if(uInBufStatus & PS_INBUF_STATUS_MASK)
{
//printf((DBG_ERROR, "The input buffer of pixel shader is not ready);
*ready = (unsigned int)INPUT_BUFFER_NOT_READY;
ret = FGL_ERR_NO_ERROR;
}
else
{
//printf((DBG_ERROR, "The input buffer of pixel shader is not ready);
*ready = (unsigned int)INPUT_BUFFER_READY;
ret = FGL_ERR_NO_ERROR;
}
return ret;
}
/*****************************************************************************
* FUNCTIONS: fglLoadVShader
* SYNOPSIS: this function uploads a vertex shader program to shader memory
* such as constant integer, float and instruction.
* PARAMETERS: [in] pShaderCode - the pointer of vertex shader program.
* RETURNS: FGL_ERR_NO_ERROR, if successful
* FGL_ERR_INVALID_VALUE - the program count exceeds the range of 512 slots
* FGL_ERR_INVALID_SHADER_CODE - either magic number or shader version
* were not an accepted value.
* ERRNO: FGL_ERR_NO_ERROR 1
* FGL_ERR_INVALID_VALUE 7
* FGL_ERR_INVALID_SHADER_CODE 8
*****************************************************************************/
FGL_Error
fglLoadVShader (const unsigned int *pShaderCode )
{
unsigned int i;
unsigned int size;
unsigned int offset = 0;
unsigned int AttribIdx = 0;
unsigned int IdxVal = 0;
volatile unsigned int *pAddr;
volatile unsigned int *pShaderData;
FGL_ShaderHeader *pShaderHeader = (FGL_ShaderHeader*)pShaderCode;
unsigned int *pShaderBody = (unsigned int*)(&pShaderHeader[1]);
if ((pShaderHeader->Magic != VERTEX_SHADER_MAGIC) || (pShaderHeader->Version != SHADER_VERSION))
{
return FGL_ERR_INVALID_SHADER_CODE;
}
if((pShaderHeader->InTableSize != 0) && (pShaderHeader->OutTableSize != 0))
{
// TODO
WRITEREG(FGVS_ATTRIB_NUM, ( (pShaderHeader->InTableSize)<<ATTRIBUTE_NUM_SHIFT)
|(pShaderHeader->OutTableSize));
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -