mirror of
https://github.com/Ttanasart-pt/Pixel-Composer.git
synced 2024-12-28 16:06:20 +01:00
296 lines
No EOL
8.6 KiB
Text
296 lines
No EOL
8.6 KiB
Text
#region vertex format
|
|
vertex_format_begin();
|
|
vertex_format_add_position_3d();
|
|
global.VF_POS = vertex_format_end();
|
|
|
|
vertex_format_begin();
|
|
vertex_format_add_position_3d();
|
|
vertex_format_add_color();
|
|
global.VF_POS_COL = vertex_format_end();
|
|
|
|
vertex_format_begin();
|
|
vertex_format_add_position_3d(); // x y z // 12
|
|
vertex_format_add_normal(); // x y z // 12
|
|
vertex_format_add_texcoord(); // u v // 8
|
|
vertex_format_add_color(); // r g b a // 4
|
|
vertex_format_add_custom(vertex_type_float3, vertex_usage_texcoord); // x y z // 12 // barycentric
|
|
global.VF_POS_NORM_TEX_COL = vertex_format_end();
|
|
global.VF_POS_NORM_TEX_COL_size = 48;
|
|
|
|
#macro vertex_pos3 vertex_position_3d
|
|
#macro vertex_norm vertex_normal
|
|
#macro vertex_texc vertex_texcoord
|
|
#macro vertex_colr vertex_color
|
|
#macro vertex_vec3 vertex_float3
|
|
#endregion
|
|
|
|
function __3dObject() constructor {
|
|
object_counts = 1;
|
|
vertex = [];
|
|
VB = [];
|
|
VF = global.VF_POS_COL;
|
|
NVB = noone;
|
|
WVB = noone;
|
|
|
|
transform = new __transform();
|
|
size = new __vec3(1);
|
|
|
|
normal_draw_size = 0.2;
|
|
render_type = pr_trianglelist;
|
|
|
|
custom_shader = noone;
|
|
texture_flip = false;
|
|
materials = [];
|
|
material_index = [];
|
|
|
|
////- Object
|
|
|
|
static checkParameter = function(params = {}, forceUpdate = false) {
|
|
var _keys = struct_get_names(params);
|
|
|
|
if(forceUpdate) {
|
|
struct_override(self, params);
|
|
onParameterUpdate();
|
|
return;
|
|
}
|
|
|
|
var check = false;
|
|
for( var i = 0, n = array_length(_keys); i < n; i++ ) {
|
|
var key = _keys[i];
|
|
if(!isEqual(self[$ key], params[$ key]))
|
|
check = true;
|
|
self[$ key] = params[$ key];
|
|
}
|
|
|
|
if(check) onParameterUpdate();
|
|
}
|
|
|
|
static onParameterUpdate = function() {}
|
|
|
|
////- Verticies
|
|
|
|
static generateNormal = function(_s = normal_draw_size) {
|
|
if(render_type != pr_trianglelist) return;
|
|
|
|
if(is_array(NVB)) array_foreach(NVB, function(v) /*=>*/ {return vertex_delete_buffer(v)});
|
|
NVB = array_verify(NVB, object_counts);
|
|
|
|
for( var i = 0; i < object_counts; i++ ) {
|
|
var _obj = vertex[i];
|
|
var _nvb = vertex_create_buffer();
|
|
|
|
vertex_begin(_nvb, global.VF_POS_COL);
|
|
for( var j = 0, n = array_length(_obj); j < n; j++ ) {
|
|
var _v = _obj[j];
|
|
|
|
vertex_position_3d(_nvb, _v.x, _v.y, _v.z);
|
|
vertex_color(_nvb, c_red, 1);
|
|
|
|
vertex_position_3d(_nvb, _v.x + _v.nx * _s, _v.y + _v.ny * _s, _v.z + _v.nz * _s);
|
|
vertex_color(_nvb, c_red, 1);
|
|
}
|
|
vertex_end(_nvb);
|
|
NVB[i] = _nvb;
|
|
}
|
|
}
|
|
|
|
static buildVertex = function(_vertex) {
|
|
var _buffer = vertex_create_buffer();
|
|
vertex_begin(_buffer, VF);
|
|
|
|
switch(VF) {
|
|
case global.VF_POS_COL :
|
|
for( var i = 0, n = array_length(_vertex); i < n; i++ ) {
|
|
var v = _vertex[i];
|
|
vertex_position_3d( _buffer, v.x, v.y, v.z);
|
|
vertex_color( _buffer, v.color, v.alpha);
|
|
}
|
|
break;
|
|
|
|
case global.VF_POS_NORM_TEX_COL :
|
|
for( var i = 0, n = array_length(_vertex); i < n; i += 3 ) {
|
|
var v0 = _vertex[i + 0];
|
|
var v1 = _vertex[i + 1];
|
|
var v2 = _vertex[i + 2];
|
|
|
|
vertex_position_3d( _buffer, v0.x, v0.y, v0.z);
|
|
vertex_normal( _buffer, v0.nx, v0.ny, v0.nz);
|
|
vertex_texcoord( _buffer, v0.u, v0.v);
|
|
vertex_color( _buffer, v0.color, v0.alpha);
|
|
vertex_float3( _buffer, 255, 0, 0);
|
|
|
|
vertex_position_3d( _buffer, v1.x, v1.y, v1.z);
|
|
vertex_normal( _buffer, v1.nx, v1.ny, v1.nz);
|
|
vertex_texcoord( _buffer, v1.u, v1.v);
|
|
vertex_color( _buffer, v1.color, v1.alpha);
|
|
vertex_float3( _buffer, 0, 255, 0);
|
|
|
|
vertex_position_3d( _buffer, v2.x, v2.y, v2.z);
|
|
vertex_normal( _buffer, v2.nx, v2.ny, v2.nz);
|
|
vertex_texcoord( _buffer, v2.u, v2.v);
|
|
vertex_color( _buffer, v2.color, v2.alpha);
|
|
vertex_float3( _buffer, 0, 0, 255);
|
|
}
|
|
break;
|
|
}
|
|
|
|
vertex_end(_buffer);
|
|
|
|
return _buffer;
|
|
}
|
|
|
|
static build = function(_buffer = VB, _vertex = vertex, counts = object_counts) {
|
|
if(is_array(_buffer)) array_foreach(_buffer, function(b) /*=>*/ { if(b != noone) vertex_delete_buffer(b); });
|
|
else if(_buffer != noone) vertex_delete_buffer(_buffer);
|
|
|
|
if(array_empty(_vertex)) return noone;
|
|
|
|
var _res = array_create(counts);
|
|
for( var i = 0; i < counts; i++ )
|
|
_res[i] = buildVertex(_vertex[i]);
|
|
|
|
return _res;
|
|
}
|
|
|
|
////- Submit
|
|
|
|
static preSubmitVertex = function(scene = {}) {}
|
|
static postSubmitVertex = function(scene = {}) {}
|
|
|
|
static getCenter = function() { return new __vec3(transform.position.x, transform.position.y, transform.position.z); }
|
|
static getBBOX = function() { return new __bbox3D(size.multiplyVec(transform.scale).multiply(-0.5), size.multiplyVec(transform.scale).multiply(0.5)); }
|
|
|
|
static submit = function(scene = {}, shader = noone) { submitVertex(scene, shader); }
|
|
static submitUI = function(scene = {}, shader = noone) { submitVertex(scene, shader); }
|
|
static submitSel = function(scene = {}, shader = noone) {
|
|
var _s = variable_clone(scene);
|
|
_s.show_normal = false;
|
|
submitVertex(_s, sh_d3d_silhouette);
|
|
}
|
|
|
|
static submitShader = function(scene = {}, shader = noone) {}
|
|
static submitShadow = function(scene = {}, object = noone) {}
|
|
|
|
static submitVertex = function(scene = {}, shader = noone) {
|
|
var _shader;
|
|
|
|
switch(VF) {
|
|
case global.VF_POS_COL: _shader = sh_d3d_wireframe; break;
|
|
case global.VF_POS_NORM_TEX_COL:
|
|
default : _shader = sh_d3d_default; break;
|
|
}
|
|
|
|
if(custom_shader != noone) _shader = custom_shader;
|
|
if(shader != noone) _shader = shader;
|
|
if(!is_undefined(shader)) shader_set(_shader);
|
|
|
|
preSubmitVertex(scene);
|
|
transform.submitMatrix();
|
|
matrix_set(matrix_world, matrix_stack_top());
|
|
|
|
gpu_set_tex_repeat(true);
|
|
for( var i = 0, n = array_length(VB); i < n; i++ ) {
|
|
var _ind = array_safe_get_fast(material_index, i, i);
|
|
var _mat = array_safe_get_fast(materials, _ind, noone);
|
|
var _useMat = is_instanceof(_mat, __d3dMaterial);
|
|
|
|
shader_set_i("mat_flip", texture_flip);
|
|
var _tex = _useMat? _mat.getTexture() : -1;
|
|
|
|
if(_shader == sh_d3d_default) {
|
|
if(_useMat) {
|
|
_mat.submitShader();
|
|
} else {
|
|
shader_set_f("mat_diffuse", 1);
|
|
shader_set_f("mat_specular", 0);
|
|
shader_set_f("mat_shine", 1);
|
|
shader_set_i("mat_metalic", 0);
|
|
shader_set_f("mat_reflective", 0);
|
|
shader_set_f("mat_texScale", [ 1, 1 ] );
|
|
}
|
|
|
|
} else if(_shader == sh_d3d_geometry) {
|
|
if(_useMat) _mat.submitGeometry();
|
|
else {
|
|
shader_set_i("use_normal", 0);
|
|
shader_set_f("mat_texScale", [ 1, 1 ] );
|
|
}
|
|
|
|
}
|
|
|
|
vertex_submit(VB[i], render_type, _tex);
|
|
}
|
|
gpu_set_tex_repeat(false);
|
|
|
|
if(!is_undefined(shader)) shader_reset();
|
|
|
|
if(scene.show_normal) {
|
|
if(NVB == noone) generateNormal();
|
|
if(NVB != noone) {
|
|
shader_set(sh_d3d_wireframe);
|
|
shader_set_color("blend", c_white);
|
|
array_foreach(NVB, function(n) /*=>*/ {vertex_submit(n, pr_linelist, -1)});
|
|
shader_reset();
|
|
}
|
|
}
|
|
|
|
transform.clearMatrix();
|
|
matrix_set(matrix_world, matrix_build_identity());
|
|
postSubmitVertex(scene);
|
|
|
|
}
|
|
|
|
////- Actions
|
|
|
|
static clone = function(_vertex = true, cloneBuffer = false) {
|
|
var _obj = new __3dObject();
|
|
|
|
if(_vertex) {
|
|
_obj.vertex = array_create(array_length(vertex));
|
|
for( var i = 0, n = array_length(vertex); i < n; i++ ) {
|
|
_obj.vertex[i] = array_create(array_length(vertex[i]));
|
|
|
|
for( var j = 0, m = array_length(vertex[i]); j < m; j++ )
|
|
_obj.vertex[i][j] = vertex[i][j].clone();
|
|
}
|
|
}
|
|
|
|
if(cloneBuffer) {
|
|
_obj.VB = array_create(array_length(VB));
|
|
|
|
for( var i = 0, n = array_length(VB); i < n; i++ ) {
|
|
var _vnum = vertex_get_number(VB[i]);
|
|
var _buff = buffer_create(1, buffer_grow, 1);
|
|
buffer_copy_from_vertex_buffer(VB[i], 0, _vnum - 1, _buff, 0);
|
|
|
|
_obj.VB[i] = vertex_create_buffer_from_buffer(_buff, VF);
|
|
}
|
|
} else {
|
|
_obj.VB = [];
|
|
}
|
|
|
|
_obj.NVB = NVB;
|
|
_obj.VF = VF;
|
|
_obj.render_type = render_type;
|
|
_obj.custom_shader = custom_shader;
|
|
_obj.object_counts = object_counts;
|
|
_obj.transform = transform.clone();
|
|
_obj.size = size.clone();
|
|
_obj.materials = materials;
|
|
_obj.material_index = material_index;
|
|
_obj.texture_flip = texture_flip;
|
|
|
|
return _obj;
|
|
}
|
|
|
|
static destroy = function() {
|
|
for( var i = 0, n = array_length(VB); i < n; i++ )
|
|
vertex_delete_buffer(VB[i]);
|
|
VB = [];
|
|
onDestroy();
|
|
}
|
|
|
|
static onDestroy = function() { }
|
|
|
|
static toString = function() { return $"[D3D Object]\n\t({array_length(vertex)} vertex groups\n\tPosition: {transform.position}\n\tRotation: {transform.rotation}\n\tScale: {transform.scale})" }
|
|
} |