libgui/include/gui/video/shaders/VertexShader.h
2019-08-14 23:24:55 +02:00

168 lines
6.0 KiB
C++

/****************************************************************************
* Copyright (C) 2015 Dimok
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#ifndef VERTEX_SHADER_H
#define VERTEX_SHADER_H
#include <string.h>
#include <gui/video/shaders/Shader.h>
#include <gui/gx2_ext.h>
class VertexShader : public Shader {
public:
VertexShader(uint32_t numAttr)
: attributesCount( numAttr )
, attributes( new GX2AttribStream[attributesCount] )
, vertexShader( (GX2VertexShader*) memalign(0x40, sizeof(GX2VertexShader)) ) {
if(vertexShader) {
memset(vertexShader, 0, sizeof(GX2VertexShader));
vertexShader->mode = GX2_SHADER_MODE_UNIFORM_REGISTER;
}
}
virtual ~VertexShader() {
delete [] attributes;
if(vertexShader) {
if(vertexShader->program)
free(vertexShader->program);
for(uint32_t i = 0; i < vertexShader->uniformBlockCount; i++)
free((void*)vertexShader->uniformBlocks[i].name);
if(vertexShader->uniformBlocks)
free((void*)vertexShader->uniformBlocks);
for(uint32_t i = 0; i < vertexShader->uniformVarCount; i++)
free((void*)vertexShader->uniformVars[i].name);
if(vertexShader->uniformVars)
free((void*)vertexShader->uniformVars);
if(vertexShader->initialValues)
free((void*)vertexShader->initialValues);
for(uint32_t i = 0; i < vertexShader->samplerVarCount; i++)
free((void*)vertexShader->samplerVars[i].name);
if(vertexShader->samplerVars)
free((void*)vertexShader->samplerVars);
for(uint32_t i = 0; i < vertexShader->attribVarCount; i++)
free((void*)vertexShader->attribVars[i].name);
if(vertexShader->attribVars)
free((void*)vertexShader->attribVars);
if(vertexShader->loopVars)
free((void*)vertexShader->loopVars);
free(vertexShader);
}
}
void setProgram(const uint32_t * program, const uint32_t & programSize, const uint32_t * regs, const uint32_t & regsSize) {
if(!vertexShader)
return;
//! this must be moved into an area where the graphic engine has access to and must be aligned to 0x100
vertexShader->size = programSize;
vertexShader->program = (uint8_t*) memalign(GX2_SHADER_PROGRAM_ALIGNMENT, vertexShader->size);
if(vertexShader->program) {
memcpy(vertexShader->program, program, vertexShader->size);
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_SHADER, vertexShader->program, vertexShader->size);
}
memcpy(&vertexShader->regs, regs, regsSize);
}
void addUniformVar(const GX2UniformVar & var) {
if(!vertexShader)
return;
uint32_t idx = vertexShader->uniformVarCount;
GX2UniformVar* newVar = (GX2UniformVar*) malloc((vertexShader->uniformVarCount + 1) * sizeof(GX2UniformVar));
if(newVar) {
if(vertexShader->uniformVarCount > 0) {
memcpy(newVar, vertexShader->uniformVars, vertexShader->uniformVarCount * sizeof(GX2UniformVar));
free(vertexShader->uniformVars);
}
vertexShader->uniformVars = newVar;
memcpy(vertexShader->uniformVars + idx, &var, sizeof(GX2UniformVar));
vertexShader->uniformVars[idx].name = (char*) malloc(strlen(var.name) + 1);
strcpy((char*)vertexShader->uniformVars[idx].name, var.name);
vertexShader->uniformVarCount++;
}
}
void addAttribVar(const GX2AttribVar & var) {
if(!vertexShader)
return;
uint32_t idx = vertexShader->attribVarCount;
GX2AttribVar* newVar = (GX2AttribVar*) malloc((vertexShader->attribVarCount + 1) * sizeof(GX2AttribVar));
if(newVar) {
if(vertexShader->attribVarCount > 0) {
memcpy(newVar, vertexShader->attribVars, vertexShader->attribVarCount * sizeof(GX2AttribVar));
free(vertexShader->attribVars);
}
vertexShader->attribVars = newVar;
memcpy(vertexShader->attribVars + idx, &var, sizeof(GX2AttribVar));
vertexShader->attribVars[idx].name = (char*) malloc(strlen(var.name) + 1);
strcpy((char*)vertexShader->attribVars[idx].name, var.name);
vertexShader->attribVarCount++;
}
}
static inline void setAttributeBuffer(uint32_t bufferIdx, uint32_t bufferSize, uint32_t stride, const void * buffer) {
GX2SetAttribBuffer(bufferIdx, bufferSize, stride, (void*)buffer);
}
GX2VertexShader *getVertexShader() const {
return vertexShader;
}
void setShader(void) const {
GX2SetVertexShader(vertexShader);
}
GX2AttribStream * getAttributeBuffer(uint32_t idx = 0) const {
if(idx >= attributesCount) {
return NULL;
}
return &attributes[idx];
}
uint32_t getAttributesCount() const {
return attributesCount;
}
static void setUniformReg(uint32_t location, uint32_t size, const void * reg) {
GX2SetVertexUniformReg(location, size, (uint32_t*)reg);
}
protected:
uint32_t attributesCount;
GX2AttribStream *attributes;
GX2VertexShader *vertexShader;
};
#endif // VERTEX_SHADER_H